Introducing the Canonical Crosswalk Admission Protocol v1.0

The next hardening move is simple: the Civilisation Crosswalk Registry can no longer behave only as an index. It now has to behave as an admission gate. The registry page already defines the common translation pipeline — outside concept -> CivOS object -> lattice position -> time behavior -> sensors -> failure mode -> repair path — and says future entries should enter only when they can be translated into the same canonical fields. It also explicitly frames the registry as a control device that makes gaps visible and prevents random branch sprawl. (eduKate Singapore)

The Ministry of Education V2.0 upgrade is the proof that this is now necessary. That page moved the ministry from an administrative body into a civilisational capability engine and a national control tower for capability transfer, corridor repair, routing, continuity, and future survival. It also showed what happens when a real institution is fully crosswalked into a larger system rather than described in isolation. (eduKate Singapore)

So the protocol below is the cage-hardening rule: from this point onward, no new major CivOS branch should count as canonical merely because it is interesting, well-written, or adjacent. It should count as canonical only if it can be admitted through the same translation grammar, the same time discipline, and the same repair discipline already laid down by the registry. That is the shift from rich framework to controlled architecture. (eduKate Singapore)

Start Here: https://edukatesg.com/how-civilisation-works-mechanics-not-history/how-civilisation-works-the-machine/how-civilisation-works-the-builders/civilisation-crosswalk-registry-v1-0/

One-Sentence Definition

Canonical Crosswalk Admission Protocol v1.0 is the gatekeeping rule that decides whether a new concept, institution, field, or branch is allowed into CivOS canon by forcing it through a common translation, time, sensor, failure, repair, and cross-binding grammar.

Why This Protocol Is Needed

Without an admission protocol, a framework can still become large but remain partly hand-assembled. The registry page says exactly this: without a registry, the framework remains rich but partly hand-assembled; with a registry, it becomes more disciplined, interoperable, and scalable. The protocol simply takes that logic one step further. It converts “same fields preferred” into “same fields required.” (eduKate Singapore)

That matters because the current branch has already reached the point where import power is real. The registry already names future candidates such as education, family, language, repair systems, institutional drift, city systems, and narrative gravity / civilisational relativity. Once the system can absorb that many branches, it needs a harder intake rule or it will grow unevenly. (eduKate Singapore)

The Core Admission Law

A new entry is canonical only if it can answer one operational question clearly:

What is this, operationally, inside the civilisation machine? (eduKate Singapore)

If that cannot be answered in a stable way, the entry may still be interesting, but it is not yet canon.

Mandatory Admission Sequence

Every candidate entry must pass through this sequence:

Outside concept -> CivOS object -> lattice position -> time behavior -> sensors -> failure mode -> repair path -> cross-OS bindings -> host effect -> admission status. The first seven stages come directly from the registry’s canonical translation rule; the last three harden it into a formal gate. (eduKate Singapore)

Mandatory Canonical Fields

Every new canonical entry must declare these fields, because the registry already defines them as the stable grammar:

Source Term
Source Domain
CivOS Translation
Primary Object
Main Zoom Range
Primary Phase Relevance
Core Rule
Main Sensors
Main Failure Mode
Main Repair Lever
Cross-OS Bindings (eduKate Singapore)

To harden the cage, three more fields should now become compulsory:

Host Effect Classification
ChronoFlight / Time Behavior
Admission Status

These are not arbitrary additions. The registry already says concepts must declare host effect and time behavior, and that every registry object should be treated as a ChronoFlight object rather than a snapshot. (eduKate Singapore)

Host Effect Rule

No concept enters canon based on prestige, surface appeal, or the reputation of its source field. The registry already warns that imported concepts should be checked for host effect: whether they widen corridor viability, produce mixed effects, or thin corridor viability inside the host civilisation. (eduKate Singapore)

So every admitted entry must be classified as one of:

Positive host effect
Mixed / conditional host effect
Negative / thinning host effect

This prevents fashionable imports from entering as hidden destabilizers.

Time Rule

No entry is canonical if it can only be described as a snapshot. The registry says every object should be treated as a ChronoFlight object and read through time as emerging, stabilizing, drifting, hollowing, being repaired, collapsing, or reconstituting. (eduKate Singapore)

So each candidate must include a minimum time-path reading:

how it emerges
how it stabilizes
how it drifts
how it hollows
how it collapses
how it can be repaired or reconstituted

If that time-path is missing, the entry is incomplete.

Admission Thresholds

A new entry passes into canon only if it satisfies all six threshold tests below.

1. Translation Threshold

The outside concept must become a clear CivOS object, not remain decorative language. This follows the registry’s rule that nothing imported should remain decorative. (eduKate Singapore)

2. Location Threshold

The entry must declare where it lives: its primary lattice, zoom range, and phase relevance. (eduKate Singapore)

3. Sensor Threshold

The entry must expose observable signals strong enough to detect strengthening, thinning, drift, or breakage. The registry explicitly requires main sensors. (eduKate Singapore)

4. Failure Threshold

The entry must state how it collapses or distorts in runtime, not just how it looks when healthy. (eduKate Singapore)

5. Repair Threshold

The entry must state what restores viable function. If repair cannot be named, the entry is not yet operational enough for canon. (eduKate Singapore)

6. Binding Threshold

The entry must show cross-OS bindings. If it cannot bind to adjacent branches, it is still too isolated. The registry requires cross-OS bindings, and the MOE upgrade shows why: real institutional resilience depends on linked subsystems rather than siloed definition. (eduKate Singapore)

Admission Status Classes

To prevent all-or-nothing chaos, each candidate should receive one of four statuses.

1. Candidate

Interesting and relevant, but not yet translated into full CivOS grammar.

2. Provisional

Translated into object form and partially located, but missing some sensors, failure logic, or repair logic.

3. Admitted

Meets the full canonical field requirement and passes the threshold tests.

4. Canon Locked

Admitted, applied in at least one real institutional or civilisational port, and shown to bind coherently with the existing stack.

The MOE V2.0 page is important here because it illustrates what “Canon Locked” should look like: a branch that not only defines itself, but ports into a real organ and proves crosswalk value in application. That is an inference from the registry logic plus the MOE implementation, but it is a strong one. (eduKate Singapore)

Rejection Conditions

A proposed branch should be rejected or held outside canon if any of the following is true:

It stays as metaphor only.
It cannot be mapped to a primary CivOS object.
It cannot name sensors.
It cannot name its failure mode.
It cannot name repair logic.
It has no host-effect reading.
It has no time-path reading.
It duplicates an existing branch without differentiation.
It widens terminology but not runtime clarity.

The registry already frames itself as a control device that helps identify overlap, missing pieces, underdeveloped branches, and concepts needing differentiation. This rejection layer simply operationalizes that function. (eduKate Singapore)

Canonical Admission Workflow

The clean workflow is:

Nominate the concept.
Translate it into CivOS object form.
Place it on the lattice.
Define its zoom and phase relevance.
Define its core rule.
Name its sensors.
Name its failure mode.
Name its repair lever.
Bind it to adjacent OS branches.
Classify its host effect.
Give it a ChronoFlight reading.
Assign admission status.
If strong enough, port it into one real applied page.
Reassess for Canon Locked status.

That is the whole gate.

What This Changes

This protocol changes the nature of CivOS growth.

Before this, growth could still happen by branch expansion.

After this, growth becomes controlled by admission discipline.

That means future work becomes easier to judge:

Is this a real branch or just a nice phrase?
Is this already covered elsewhere?
Is this missing sensors?
Is this only conceptual, or is it runnable?
Can it port into a real system?
Does it widen the machine or just decorate it?

That is how the cage hardens.

Final Definition

Canonical Crosswalk Admission Protocol v1.0 is the rule that prevents CivOS from becoming random branch sprawl by forcing every new entry to declare its object, location, time behavior, sensors, failure mode, repair path, host effect, and system bindings before it is allowed into canon.

Almost-Code

			
ENTITY: CanonicalCrosswalkAdmissionProtocolV1_0
PURPOSE:
- harden_civos_cage
- prevent_random_branch_sprawl
- standardize_ingestion
- preserve_runtime_coherence
- convert_registry_from_index_to_gate
CORE_LAW:
- no_new_branch_is_canonical_unless_it_passes_common_translation_grammar
MANDATORY_PIPELINE:
- outside_concept
- civos_object
- lattice_position
- time_behavior
- sensors
- failure_mode
- repair_path
- cross_os_bindings
- host_effect
- admission_status
MANDATORY_FIELDS:
- SourceTerm
- SourceDomain
- CivOSTranslation
- PrimaryObject
- MainZoomRange
- PrimaryPhaseRelevance
- CoreRule
- MainSensors
- MainFailureMode
- MainRepairLever
- CrossOSBindings
- HostEffectClassification
- ChronoFlightReading
- AdmissionStatus
HOST_EFFECT_CLASSES:
- Positive
- MixedConditional
- NegativeThinning
CHRONOFLIGHT_MINIMUM:
- emerging
- stabilizing
- drifting
- hollowing
- collapsing
- repairing
- reconstituting
PASS_TESTS:
- TranslationThreshold = object_is_clear
- LocationThreshold = lattice_zoom_phase_declared
- SensorThreshold = measurable_signals_exist
- FailureThreshold = runtime_breakage_defined
- RepairThreshold = viable_restoration_defined
- BindingThreshold = adjacent_os_links_defined
ADMISSION_STATUS:
- Candidate
- Provisional
- Admitted
- CanonLocked
REJECTION_RULES:
- reject_if metaphor_only
- reject_if no_primary_object
- reject_if no_sensors
- reject_if no_failure_mode
- reject_if no_repair_logic
- reject_if no_host_effect
- reject_if no_time_behavior
- reject_if duplicate_without_differentiation
- reject_if runtime_clarity_not_improved
CANON_LOCK_RULE:
- CanonLocked only_if:
  - full_fields_complete
  - pass_tests_all_true
  - cross_os_bindings_coherent
  - at_least_one_real_applied_port_exists
OUTPUT:
- CivOS grows by controlled admission, not uncontrolled accumulation

		

			
```yaml id="5q4m7a"
ENTITY:
  id: CIVOS.CROSSWALK.ADMISSION.V1_0
  name: CanonicalCrosswalkAdmissionProtocolV1_0
  class: GatekeepingProtocol
  status: CanonicalSpecification
  version: 1.0
  canonical_phrase: Canonical Crosswalk Admission Protocol v1.0
  mission:
    - HardenCivOSCage
    - PreventRandomBranchSprawl
    - StandardizeCrosswalkAdmission
    - PreserveCanonicalCoherence
    - ForceOperationalTranslation
    - BindNewEntriesIntoRuntime
  compressed_definition:
    - Gatekeeping protocol that determines whether a new concept, institution, theory, or branch may enter CivOS canon by forcing it through a common translation, lattice, time, sensor, failure, repair, and cross-binding grammar.
CLASSICAL_BASELINE:
  description:
    - Admission protocol for a knowledge system defines what may enter, under what rules, in what format, with what validation, and with what status.
  civos_extension:
    - In CivOS, admission is not based on novelty, prestige, elegance, or rhetorical power.
    - Admission is based on operational fit, lattice legibility, time behavior, sensor clarity, failure logic, repair logic, host effect, and cross-OS binding strength.
ONTOLOGY:
  parent_stack:
    - CivOS
    - CivilisationCrosswalkRegistry
    - ChronoFlight
    - LedgerOfInvariants
    - VeriWeft
    - FenceOS
    - StrategizeOS
  dependent_layers:
    - CrosswalkRegistry
    - CanonicalPublishingDiscipline
    - RuntimeControlDiscipline
    - BranchDifferentiationLayer
    - AppliedPortValidationLayer
  primitive_dependencies:
    - Lattice
    - Threshold
    - Sensor
    - FailureMode
    - Repair
    - Transfer
    - Drift
    - Buffer
    - Time
    - Gate
    - Ledger
    - CrossBinding
SCOPE:
  applies_to:
    - NewConcepts
    - NewInstitutions
    - ImportedTheories
    - AdjacentFrameworks
    - NewCivOSBranches
    - UpgradeSpecs
    - CrossDomainMappings
    - RuntimePages
  excludes:
    - UntranslatedMetaphorOnlyContent
    - DuplicateBranchesWithoutDifferentiation
    - PurePrestigeImports
    - DecorativeVocabularyWithoutOperationalRole
CORE_LAW:
  id: CCA.001
  text:
    - No new branch is canonical unless it passes the common translation grammar and declares a stable operational role inside the civilisation machine.
  compact_formula:
    - CanonicalEntry = Translation + Location + Time + Sensors + Failure + Repair + CrossBindings + HostEffect + AdmissionStatus
OPERATING_QUESTION:
  canonical_question:
    - What is this, operationally, inside the civilisation machine?
  pass_condition:
    - Candidate can answer with object clarity, lattice location, time behavior, sensors, failure mode, repair path, and cross-OS role.
  fail_condition:
    - Candidate remains descriptive, metaphorical, prestige-led, or thematically vague.
AXES:
  zoom:
    Z0: IndividualFunction
    Z1: FamilyLocalSupport
    Z2: OrganRuntime
    Z3: InstitutionalSystem
    Z4: NationalCapability
    Z5: CivilisationalContinuity
    Z6: InterCivilisationalPosition
  phase:
    P0: CollapsedOrUnusable
    P1: FragileOrPartial
    P2: FunctionalButUneven
    P3: StableTransferableHighDefinition
  time:
    T0: Emergence
    T1: EarlyFormation
    T2: Stabilization
    T3: MatureOperation
    T4: Drift
    T5: Hollowing
    T6: Crisis
    T7: Repair
    T8: Reconstitution
    T9: LongHorizonCivilisationalCarry
  admission_state:
    A0: Unformed
    A1: Candidate
    A2: Provisional
    A3: Admitted
    A4: CanonLocked
  host_effect_band:
    HN: NegativeThinning
    HM: MixedConditional
    HP: PositiveWidening
LATTICE:
  id: CANONICAL_CROSSWALK_ADMISSION_LATTICE
  type: GatekeepingAndBindingLattice
  state_signature:
    X(t):
      - TranslationIntegrity
      - ObjectClarity
      - LatticeLocationClarity
      - ZoomCoverageClarity
      - PhaseClarity
      - TimeBehaviorClarity
      - SensorLegibility
      - FailureLegibility
      - RepairLegibility
      - CrossOSBindingStrength
      - HostEffectClarity
      - DifferentiationStrength
      - RuntimeUsefulness
      - AppliedPortEvidence
      - CanonicalCoherence
      - RedundancyRisk
      - DriftRisk
      - ParserReadiness
      - AdmissionScore
  bands:
    positive_lattice:
      meaning: CanonicallyAdmissibleAndStructurallyUseful
      condition:
        - TranslationIntegrity >= 0.82
        - ObjectClarity >= 0.82
        - TimeBehaviorClarity >= 0.75
        - SensorLegibility >= 0.75
        - FailureLegibility >= 0.75
        - RepairLegibility >= 0.75
        - CrossOSBindingStrength >= 0.75
        - HostEffectClarity >= 0.70
        - DifferentiationStrength >= 0.70
        - RuntimeUsefulness >= 0.75
        - CanonicalCoherence >= 0.80
    neutral_lattice:
      meaning: StructurallyInterestingButNotYetLocked
      condition:
        - TranslationIntegrity in [0.60,0.82)
        - ObjectClarity in [0.60,0.82)
        - SensorLegibility in [0.55,0.75)
        - RepairLegibility in [0.55,0.75)
        - CrossOSBindingStrength in [0.50,0.75)
        - CanonicalCoherence in [0.60,0.80)
    negative_lattice:
      meaning: NotReadyForCanonOrStructurallyWeak
      condition:
        - TranslationIntegrity < 0.60
        - OR ObjectClarity < 0.60
        - OR SensorLegibility < 0.55
        - OR FailureLegibility < 0.55
        - OR RepairLegibility < 0.55
        - OR CrossOSBindingStrength < 0.50
        - OR CanonicalCoherence < 0.60
  transition_logic:
    A0_to_A1:
      rule:
        - source_term_identified
        - source_domain_identified
        - preliminary_civos_translation_exists
    A1_to_A2:
      rule:
        - mandatory_fields_partially_filled
        - primary_object_declared
        - at_least_one_sensor_declared
        - at_least_one_failure_mode_declared
    A2_to_A3:
      rule:
        - all_mandatory_fields_complete
        - threshold_tests_pass
        - host_effect_classified
        - chrono_reading_complete
        - cross_os_bindings_complete
    A3_to_A4:
      rule:
        - applied_port_exists
        - port_is_coherent
        - runtime_usefulness_verified
        - redundancy_risk_low
        - canonical_coherence_high
MANDATORY_FIELDS:
  registry:
    - SourceTerm
    - SourceDomain
    - CivOSTranslation
    - PrimaryObject
    - MainZoomRange
    - PrimaryPhaseRelevance
    - CoreRule
    - MainSensors
    - MainFailureMode
    - MainRepairLever
    - CrossOSBindings
    - HostEffectClassification
    - ChronoFlightReading
    - AdmissionStatus
  minimum_completion_rule:
    - All fields required for Admitted and CanonLocked states.
    - Partial completion allowed only for Candidate and Provisional states.
FIELD_DEFINITIONS:
  SourceTerm:
    meaning: Original imported or proposed concept label
  SourceDomain:
    meaning: External or internal domain where concept originated
  CivOSTranslation:
    meaning: Precise CivOS-native operational rendering
  PrimaryObject:
    meaning: Main machine-role object category
  MainZoomRange:
    meaning: Dominant Z-range where object exerts strongest effect
  PrimaryPhaseRelevance:
    meaning: Dominant stability or collapse phase relevance
  CoreRule:
    meaning: Compressed operational law or mechanism
  MainSensors:
    meaning: Observable indicators that detect state changes
  MainFailureMode:
    meaning: Main distortion, thinning, breakdown, or collapse path
  MainRepairLever:
    meaning: Primary restorative mechanism
  CrossOSBindings:
    meaning: Linked systems required for coherent runtime reading
  HostEffectClassification:
    meaning: Whether imported concept widens, conditionally affects, or thins corridor viability in host civilisation
  ChronoFlightReading:
    meaning: Time-path through emergence, stabilization, drift, hollowing, collapse, repair, or reconstitution
  AdmissionStatus:
    meaning: Candidate, Provisional, Admitted, or CanonLocked
PRIMARY_OBJECT_CLASSES:
  allowed_classes:
    - Organ
    - ControlPrimitive
    - Sensor
    - Ledger
    - Corridor
    - Gate
    - RuntimeOverlay
    - RepairMechanism
    - TransferMechanism
    - DistortionMechanism
    - CalibrationLayer
    - PathwaySystem
    - ContainmentSystem
    - CoordinationSystem
    - ArchiveMemoryLayer
  rejection_rule:
    - Reject if no stable object class can be assigned.
HOST_EFFECT_RULE:
  purpose:
    - PreventPrestigeLedAdmission
    - ForceHostCivilisationReading
  classes:
    PositiveWidening:
      code: HP
      rule:
        - widens_corridor
        - improves_legibility
        - increases_repair_capacity
        - preserves_or_strengthens_base_floor
    MixedConditional:
      code: HM
      rule:
        - useful_under_bounded_conditions
        - may_strengthen_one_layer_while_thinning_another
        - requires_explicit_safeguards
    NegativeThinning:
      code: HN
      rule:
        - narrows_corridor
        - weakens_legibility
        - destabilizes_invariants
        - creates hidden drift or dependency
  pass_requirement:
    - Every admitted entry must declare one host-effect classification and supporting reason.
CHRONOFLIGHT_RULE:
  purpose:
    - PreventSnapshotOnlyCanon
    - ForceTimeAwareReading
  minimum_time_path:
    - Emerging
    - Stabilizing
    - Operating
    - Drifting
    - Hollowing
    - Collapsing
    - Repairing
    - Reconstituting
  pass_requirement:
    - Entry must include at least one valid state path across time.
  chrono_fields:
    - emergence_conditions
    - stabilization_conditions
    - drift_signals
    - hollowing_signals
    - collapse_signals
    - repair_path
    - reconstitution_path
THRESHOLD_TESTS:
  TranslationThreshold:
    purpose:
      - concept_must_become_operational_object
    pass_if:
      - TranslationIntegrity >= 0.75
      - ObjectClarity >= 0.75
    fail_if:
      - metaphor_only
      - decorative_language_only
      - no stable operational meaning
  LocationThreshold:
    purpose:
      - concept_must_be_placeable_in_civos_lattice
    pass_if:
      - LatticeLocationClarity >= 0.70
      - ZoomCoverageClarity >= 0.70
      - PhaseClarity >= 0.70
    fail_if:
      - no lattice position
      - zoom ambiguous
      - phase ambiguous
  SensorThreshold:
    purpose:
      - concept_must_be_observable
    pass_if:
      - SensorLegibility >= 0.70
      - count(MainSensors) >= 2
    fail_if:
      - no measurable indicators
      - signs too vague for runtime use
  FailureThreshold:
    purpose:
      - concept_must_define_how_it_breaks
    pass_if:
      - FailureLegibility >= 0.70
    fail_if:
      - healthy_state_only
      - no runtime failure path
  RepairThreshold:
    purpose:
      - concept_must_define_how_viability_is_restored
    pass_if:
      - RepairLegibility >= 0.70
    fail_if:
      - no repair path
      - vague repair rhetoric without mechanism
  BindingThreshold:
    purpose:
      - concept_must_bind_to_adjacent_systems
    pass_if:
      - CrossOSBindingStrength >= 0.70
      - count(CrossOSBindings) >= 2
    fail_if:
      - isolated essay object
      - no systemic integration
  DifferentiationThreshold:
    purpose:
      - concept_must_not_duplicate_existing_canon_without differentiation
    pass_if:
      - DifferentiationStrength >= 0.70
      - RedundancyRisk <= 0.30
    fail_if:
      - duplicates existing branch
      - widens terminology but not runtime clarity
  CanonicalCoherenceThreshold:
    purpose:
      - concept_must_fit existing stack without internal contradiction
    pass_if:
      - CanonicalCoherence >= 0.80
    fail_if:
      - conflicts with locked primitives
      - introduces unstable ontology drift
  AppliedPortThreshold:
    purpose:
      - required for CanonLocked only
    pass_if:
      - AppliedPortEvidence >= 0.70
      - RuntimeUsefulness >= 0.75
    fail_if:
      - no applied case
      - applied case incoherent or decorative
ADMISSION_STATUS_MACHINE:
  A0_Unformed:
    meaning:
      - concept exists only as thought, note, or phrase
    requirements:
      - none
  A1_Candidate:
    meaning:
      - concept nominated and preliminarily translated
    requirements:
      - SourceTerm
      - SourceDomain
      - initial_CivOSTranslation
      - provisional_PrimaryObject
  A2_Provisional:
    meaning:
      - concept partially structured but not yet canonical
    requirements:
      - all basic fields filled
      - partial sensors
      - partial failure logic
      - partial repair logic
      - preliminary cross-bindings
  A3_Admitted:
    meaning:
      - concept structurally valid for canon
    requirements:
      - pass TranslationThreshold
      - pass LocationThreshold
      - pass SensorThreshold
      - pass FailureThreshold
      - pass RepairThreshold
      - pass BindingThreshold
      - pass DifferentiationThreshold
      - pass CanonicalCoherenceThreshold
      - HostEffectClassification complete
      - ChronoFlightReading complete
  A4_CanonLocked:
    meaning:
      - concept fully admitted and validated in applied runtime
    requirements:
      - all Admitted requirements
      - pass AppliedPortThreshold
      - parser_readiness_high
      - stable integration with existing stack
REJECTION_RULES:
  immediate_reject_conditions:
    - no_primary_object
    - no_civos_translation
    - no_sensors
    - no_failure_mode
    - no_repair_logic
    - no_host_effect
    - no_chrono_reading
    - duplicate_without_differentiation
    - rhetorical_expansion_without_runtime_gain
  hold_conditions:
    - interesting_but_underdefined
    - translation_partially_complete
    - crossbindings_insufficient
    - sensors_too_weak
    - repair_path_immature
  reentry_rule:
    - Held or rejected concepts may re-enter as Candidate if revised fields improve threshold scores.
LEDGER_OF_ADMISSION_INVARIANTS:
  id: CCA_LEDGER_V1
  invariants:
    - INV_CCA_001:
        name: NoDecorativeAdmission
        rule:
          - Every admitted object must improve runtime clarity.
    - INV_CCA_002:
        name: NoSnapshotCanon
        rule:
          - Every admitted object must have time behavior.
    - INV_CCA_003:
        name: NoIsolatedCanon
        rule:
          - Every admitted object must bind to adjacent OS layers.
    - INV_CCA_004:
        name: NoFailureBlindness
        rule:
          - Every admitted object must declare failure mode.
    - INV_CCA_005:
        name: NoRepairBlindness
        rule:
          - Every admitted object must declare repair lever.
    - INV_CCA_006:
        name: NoPrestigeOnlyImport
        rule:
          - Host effect must outrank source prestige.
    - INV_CCA_007:
        name: NoOntologyDrift
        rule:
          - New entries must not contradict locked primitives unless explicitly marked as frontier or revision branch.
    - INV_CCA_008:
        name: ParserLegibility
        rule:
          - Canonical entry should be machine-readable enough for structured reuse.
  breach_logic:
    soft_breach:
      condition:
        - one invariant partially unmet
      action:
        - downgrade_to_Provisional
        - request_field_completion
    hard_breach:
      condition:
        - one critical invariant absent
      action:
        - reject_or_hold
    systemic_breach:
      condition:
        - repeated admissions ignore invariants
      action:
        - freeze_new_admissions
        - audit_registry
        - rebuild_protocol_compliance
VERIWEFT_CHECKS:
  id: CCA_VWEFT
  purpose:
    - EnsureStructuralValidityOfAdmission
  checks:
    - terminology_consistency
    - locked_primitive_alignment
    - no_hidden_duplication
    - no_unbounded_scope_creep
    - no_crossbranch_conflict_without_explicit_resolution
    - no_false_sensor_claims
    - no_false_repair_claims
  failure_signals:
    - object_label_changes_across_pages
    - overlapping branches with unclear differentiation
    - sensors not tied to observable runtime
    - repair path detached from actual failure mode
    - time reading absent or decorative
    - admissions that widen archive but not system capability
CROSSWALK_REGISTRY_BINDING:
  id: CCA_REGISTRY_BIND
  mandatory_registry_link:
    - Every admitted entry must map into CivilisationCrosswalkRegistry fields.
  registry_export_fields:
    - SourceTerm
    - SourceDomain
    - CivOSTranslation
    - PrimaryObject
    - MainZoomRange
    - PrimaryPhaseRelevance
    - CoreRule
    - MainSensors
    - MainFailureMode
    - MainRepairLever
    - CrossOSBindings
    - HostEffectClassification
    - ChronoFlightReading
    - AdmissionStatus
  registry_import_rule:
    - Existing registry entries may be upgraded through CCA protocol without full rewrite if missing fields can be added cleanly.
SCORING_ENGINE:
  id: CCA_SCORE_ENGINE
  normalized_scale:
    min: 0.00
    max: 1.00
  variables:
    TranslationIntegrity:
      formula:
        - weighted_mean(CivOSTranslationClarity, PrimaryObjectFit, CoreRuleCompression)
    ObjectClarity:
      formula:
        - weighted_mean(PrimaryObjectFit, ScopeBoundedness, OperationalSpecificity)
    LatticeLocationClarity:
      formula:
        - weighted_mean(MainZoomRangeClarity, PrimaryPhaseClarity, LatticePlacementConfidence)
    TimeBehaviorClarity:
      formula:
        - weighted_mean(EmergenceClarity, DriftClarity, CollapseClarity, RepairTimePathClarity)
    SensorLegibility:
      formula:
        - weighted_mean(SensorCountAdequacy, ObservabilityStrength, SignalSpecificity)
    FailureLegibility:
      formula:
        - weighted_mean(FailureSpecificity, RuntimeFailurePathClarity, BoundaryVisibility)
    RepairLegibility:
      formula:
        - weighted_mean(RepairSpecificity, RepairToFailureFit, RecoveryPathClarity)
    CrossOSBindingStrength:
      formula:
        - weighted_mean(BindingCountAdequacy, BindingNecessityClarity, IntegrationStrength)
    HostEffectClarity:
      formula:
        - weighted_mean(HostEffectClassificationCompleteness, CorridorImpactClarity, ConditionalityClarity)
    DifferentiationStrength:
      formula:
        - weighted_mean(NonDuplicationClarity, ScopeDistinctness, RuntimeNovelty)
    RuntimeUsefulness:
      formula:
        - weighted_mean(OperationalApplicability, DiagnosticPower, UpgradePower)
    AppliedPortEvidence:
      formula:
        - weighted_mean(RealPortExists, PortCoherence, PortDiagnosticGain)
    CanonicalCoherence:
      formula:
        - weighted_mean(PrimitiveAlignment, TerminologyConsistency, StackCompatibility)
    ParserReadiness:
      formula:
        - weighted_mean(FieldStructureQuality, MachineReadability, SchemaConsistency)
    AdmissionScore:
      formula:
        - weighted_mean(
            TranslationIntegrity,
            ObjectClarity,
            LatticeLocationClarity,
            TimeBehaviorClarity,
            SensorLegibility,
            FailureLegibility,
            RepairLegibility,
            CrossOSBindingStrength,
            HostEffectClarity,
            DifferentiationStrength,
            RuntimeUsefulness,
            CanonicalCoherence
          )
THRESHOLDS:
  StableFieldThreshold: 0.70
  StrongFieldThreshold: 0.82
  FenceFloor: 0.55
  formulas:
    CandidateReady:
      if:
        - TranslationIntegrity >= 0.40
        - ObjectClarity >= 0.40
      then: true
    ProvisionalReady:
      if:
        - TranslationIntegrity >= 0.55
        - ObjectClarity >= 0.55
        - SensorLegibility >= 0.45
        - FailureLegibility >= 0.45
      then: true
    AdmittedReady:
      if:
        - TranslationIntegrity >= 0.75
        - ObjectClarity >= 0.75
        - LatticeLocationClarity >= 0.70
        - TimeBehaviorClarity >= 0.70
        - SensorLegibility >= 0.70
        - FailureLegibility >= 0.70
        - RepairLegibility >= 0.70
        - CrossOSBindingStrength >= 0.70
        - HostEffectClarity >= 0.70
        - DifferentiationStrength >= 0.70
        - CanonicalCoherence >= 0.80
      then: true
    CanonLockedReady:
      if:
        - AdmittedReady == true
        - AppliedPortEvidence >= 0.70
        - RuntimeUsefulness >= 0.75
        - ParserReadiness >= 0.75
      then: true
    Reject:
      if:
        - TranslationIntegrity < FenceFloor
        - OR ObjectClarity < FenceFloor
        - OR SensorLegibility < FenceFloor
        - OR FailureLegibility < FenceFloor
        - OR RepairLegibility < FenceFloor
        - OR CanonicalCoherence < FenceFloor
      then: true
WORKFLOW_ENGINE:
  id: CCA_RUNTIME
  runtime_loop:
    - NominateConcept
    - CaptureSourceTerm
    - CaptureSourceDomain
    - TranslateIntoCivOS
    - AssignPrimaryObject
    - AssignLatticeLocation
    - AssignZoomAndPhase
    - DefineCoreRule
    - DefineSensors
    - DefineFailureMode
    - DefineRepairLever
    - BindCrossOS
    - ClassifyHostEffect
    - BuildChronoFlightReading
    - ScoreEntry
    - EvaluateThresholds
    - AssignAdmissionStatus
    - ExportToRegistry
    - IfEligibleThenRequestAppliedPort
    - ReassessForCanonLock
  action_outputs:
    - HoldAsCandidate
    - UpgradeToProvisional
    - AdmitToCanon
    - LockAsCanon
    - Reject
    - RequestDifferentiation
    - RequestRepairLogic
    - RequestSensorClarification
    - RequestAppliedPort
INPUT_SCHEMA:
  required_inputs:
    - source_term
    - source_domain
    - proposed_translation
    - proposed_primary_object
    - proposed_core_rule
  optional_inputs:
    - proposed_zoom_range
    - proposed_phase_relevance
    - proposed_sensors
    - proposed_failure_mode
    - proposed_repair_lever
    - proposed_bindings
    - proposed_host_effect
    - proposed_chrono_reading
    - proposed_applied_port
OUTPUT_SCHEMA:
  fields:
    - admission_status
    - lattice_band
    - threshold_results
    - field_completeness_report
    - redundancy_risk
    - coherence_risk
    - next_required_action
    - registry_export_object
DIAGNOSTICS:
  failure_modes:
    - FM_CCA_001:
        name: MetaphorOnlyAdmission
        pattern:
          - strong_phrase
          - weak_object
          - no sensors
          - no repair
    - FM_CCA_002:
        name: PrestigeImportBias
        pattern:
          - high external prestige
          - weak host effect reasoning
    - FM_CCA_003:
        name: SnapshotOnlyCanon
        pattern:
          - no chrono path
          - healthy-state description only
    - FM_CCA_004:
        name: EssayIsolation
        pattern:
          - no cross_os_bindings
          - no runtime integration
    - FM_CCA_005:
        name: DuplicateBranchGrowth
        pattern:
          - new labels
          - old mechanism
          - weak differentiation
    - FM_CCA_006:
        name: FailureBlindness
        pattern:
          - no declared failure mode
    - FM_CCA_007:
        name: RepairBlindness
        pattern:
          - no declared repair path
    - FM_CCA_008:
        name: OntologyDrift
        pattern:
          - contradicts locked primitives
          - unstable terminology
    - FM_CCA_009:
        name: AppliedPortFailure
        pattern:
          - nominal port exists
          - but adds no diagnostic or upgrade value
  detection_logic:
    - for each failure_mode:
        if pattern_match_score >= 0.70:
          register_failure_mode
          lower_admission_score
REPAIR_PROTOCOLS:
  for_underdefined_candidate:
    - sharpen_translation
    - assign_primary_object
    - bound_scope
  for_missing_sensors:
    - define_observables
    - define_signal_thresholds
  for_missing_failure_logic:
    - specify_breakage_path
    - specify_boundary_crossing
  for_missing_repair_logic:
    - define_repair_mechanism
    - tie_repair_to_failure
  for_weak_bindings:
    - identify_adjacent_os_dependencies
    - declare minimum required bindings
  for_duplication_risk:
    - compare_against_existing_branches
    - rewrite_differentiation
    - merge_if_needed
  for_weak_coherence:
    - align_to_locked_primitives
    - normalize terminology
  for_missing_applied_port:
    - nominate_real_system_case
    - build test port
    - measure diagnostic gain
CONTROL_TOWER:
  id: CCA_CONTROL_TOWER
  panel:
    - TranslationIntegrity
    - ObjectClarity
    - LatticeLocationClarity
    - TimeBehaviorClarity
    - SensorLegibility
    - FailureLegibility
    - RepairLegibility
    - CrossOSBindingStrength
    - HostEffectClarity
    - DifferentiationStrength
    - RuntimeUsefulness
    - AppliedPortEvidence
    - CanonicalCoherence
    - ParserReadiness
    - AdmissionScore
    - AdmissionStatus
  alert_rules:
    RED:
      condition:
        - Reject == true
        - OR CanonicalCoherence < 0.55
        - OR FailureLegibility < 0.55
        - OR RepairLegibility < 0.55
    AMBER:
      condition:
        - AdmittedReady == false
        - AND ProvisionalReady == true
    GREEN:
      condition:
        - AdmittedReady == true
    BLUE:
      condition:
        - CanonLockedReady == true
  board_outputs:
    - current_status
    - dominant_failures
    - missing_fields
    - repair_actions
    - registry_readiness
    - canon_lock_readiness
PARSER_HYGIENE:
  rules:
    - use_stable_field_names
    - use_explicit_object_ids
    - avoid_mixed_prose_inside_schema_blocks
    - separate_article_shell_from_technical_schema_when_publishing_human_pages
    - preserve machine-readable consistency across versions
  parser_fail_conditions:
    - broken_schema_boundaries
    - inconsistent_field_names
    - object_label_drift
    - code_like_text_without_structure
APPLIED_PORT_RULE:
  purpose:
    - verify_real_runtime_value
  accepted_port_types:
    - InstitutionUpgrade
    - CrossDomainUpgrade
    - ControlTowerPage
    - DiagnosticRuntimePage
    - FailureRepairCase
  validation_requirements:
    - candidate_object_is_used
    - candidate_object_improves diagnostic power
    - candidate_object_improves upgrade clarity
    - bindings remain coherent in application
  canon_lock_condition:
    - no concept becomes CanonLocked without at least one coherent applied port
REGISTRY_EXPORT_TEMPLATE:
  object:
    SourceTerm: null
    SourceDomain: null
    CivOSTranslation: null
    PrimaryObject: null
    MainZoomRange: null
    PrimaryPhaseRelevance: null
    CoreRule: null
    MainSensors: []
    MainFailureMode: null
    MainRepairLever: null
    CrossOSBindings: []
    HostEffectClassification: null
    ChronoFlightReading:
      Emerging: null
      Stabilizing: null
      Operating: null
      Drifting: null
      Hollowing: null
      Collapsing: null
      Repairing: null
      Reconstituting: null
    AdmissionStatus: null
WORKED_CLASSIFIER:
  function_library:
    compute_translation_integrity:
      input:
        - translation_clarity
        - object_fit
        - core_rule_compression
      output: TranslationIntegrity
      logic: weighted_mean(input,[0.40,0.35,0.25])
    compute_object_clarity:
      input:
        - object_fit
        - scope_boundedness
        - specificity
      output: ObjectClarity
      logic: weighted_mean(input,[0.40,0.30,0.30])
    compute_sensor_legibility:
      input:
        - sensor_count_adequacy
        - observability
        - signal_specificity
      output: SensorLegibility
      logic: weighted_mean(input,[0.25,0.35,0.40])
    compute_failure_legibility:
      input:
        - failure_specificity
        - runtime_failure_path
        - boundary_visibility
      output: FailureLegibility
      logic: weighted_mean(input,[0.30,0.40,0.30])
    compute_repair_legibility:
      input:
        - repair_specificity
        - repair_failure_fit
        - recovery_path_clarity
      output: RepairLegibility
      logic: weighted_mean(input,[0.30,0.40,0.30])
    compute_binding_strength:
      input:
        - binding_count
        - binding_necessity
        - integration_strength
      output: CrossOSBindingStrength
      logic: weighted_mean(input,[0.20,0.35,0.45])
    compute_coherence:
      input:
        - primitive_alignment
        - terminology_consistency
        - stack_compatibility
      output: CanonicalCoherence
      logic: weighted_mean(input,[0.40,0.30,0.30])
  master_evaluation:
    input_state:
      - translation_clarity
      - object_fit
      - core_rule_compression
      - scope_boundedness
      - specificity
      - lattice_placement_confidence
      - zoom_clarity
      - phase_clarity
      - emergence_clarity
      - drift_clarity
      - collapse_clarity
      - repair_time_path_clarity
      - sensor_count_adequacy
      - observability
      - signal_specificity
      - failure_specificity
      - runtime_failure_path
      - boundary_visibility
      - repair_specificity
      - repair_failure_fit
      - recovery_path_clarity
      - binding_count
      - binding_necessity
      - integration_strength
      - host_effect_completeness
      - corridor_impact_clarity
      - conditionality_clarity
      - nonduplication_clarity
      - scope_distinctness
      - runtime_novelty
      - operational_applicability
      - diagnostic_power
      - upgrade_power
      - real_port_exists
      - port_coherence
      - port_diagnostic_gain
      - primitive_alignment
      - terminology_consistency
      - stack_compatibility
      - field_structure_quality
      - machine_readability
      - schema_consistency
    process:
      - TranslationIntegrity = compute_translation_integrity(...)
      - ObjectClarity = compute_object_clarity(...)
      - LatticeLocationClarity = weighted_mean([lattice_placement_confidence, zoom_clarity, phase_clarity],[0.40,0.30,0.30])
      - TimeBehaviorClarity = weighted_mean([emergence_clarity, drift_clarity, collapse_clarity, repair_time_path_clarity],[0.20,0.25,0.25,0.30])
      - SensorLegibility = compute_sensor_legibility(...)
      - FailureLegibility = compute_failure_legibility(...)
      - RepairLegibility = compute_repair_legibility(...)
      - CrossOSBindingStrength = compute_binding_strength(...)
      - HostEffectClarity = weighted_mean([host_effect_completeness, corridor_impact_clarity, conditionality_clarity],[0.35,0.40,0.25])
      - DifferentiationStrength = weighted_mean([nonduplication_clarity, scope_distinctness, runtime_novelty],[0.40,0.30,0.30])
      - RuntimeUsefulness = weighted_mean([operational_applicability, diagnostic_power, upgrade_power],[0.35,0.35,0.30])
      - AppliedPortEvidence = weighted_mean([real_port_exists, port_coherence, port_diagnostic_gain],[0.30,0.35,0.35])
      - CanonicalCoherence = compute_coherence(...)
      - ParserReadiness = weighted_mean([field_structure_quality, machine_readability, schema_consistency],[0.30,0.35,0.35])
      - AdmissionScore = weighted_mean(
          [TranslationIntegrity,ObjectClarity,LatticeLocationClarity,TimeBehaviorClarity,SensorLegibility,FailureLegibility,RepairLegibility,CrossOSBindingStrength,HostEffectClarity,DifferentiationStrength,RuntimeUsefulness,CanonicalCoherence],
          [0.10,0.09,0.08,0.08,0.09,0.09,0.09,0.10,0.06,0.07,0.08,0.07]
        )
      - RedundancyRisk = 1 - DifferentiationStrength
      - DriftRisk = 1 - CanonicalCoherence
    outputs:
      - AdmissionScore
      - AdmissionStatus
      - lattice_band
      - threshold_results
      - missing_requirements
      - recommended_action
  classification_logic:
    AdmissionStatus:
      if:
        - CanonLockedReady == true
      then: A4_CanonLocked
      elif:
        - AdmittedReady == true
      then: A3_Admitted
      elif:
        - ProvisionalReady == true
      then: A2_Provisional
      elif:
        - CandidateReady == true
      then: A1_Candidate
      else: A0_Unformed
    lattice_band:
      if:
        - AdmissionStatus in [A3_Admitted, A4_CanonLocked]
      then: +LATT
      elif:
        - AdmissionStatus == A2_Provisional
      then: 0LATT
      else: -LATT
SUCCESS_CONDITION:
  definition:
    - Protocol successfully hardens CivOS when every admitted entry is operationally translated, time-aware, sensor-legible, failure-aware, repair-aware, cross-bound, host-classified, and structurally coherent with canon.
  formula:
    success = all(
      TranslationIntegrity >= 0.75,
      ObjectClarity >= 0.75,
      LatticeLocationClarity >= 0.70,
      TimeBehaviorClarity >= 0.70,
      SensorLegibility >= 0.70,
      FailureLegibility >= 0.70,
      RepairLegibility >= 0.70,
      CrossOSBindingStrength >= 0.70,
      CanonicalCoherence >= 0.80
    )
FAILURE_CONDITION:
  definition:
    - Protocol fails when concepts enter canon through rhetoric, prestige, novelty, or proximity alone, without operational translation and runtime discipline.
  formula:
    failure = any(
      TranslationIntegrity < 0.55,
      ObjectClarity < 0.55,
      SensorLegibility < 0.55,
      FailureLegibility < 0.55,
      RepairLegibility < 0.55,
      CanonicalCoherence < 0.55
    )
COMPACT_FORMULA:
  - CCA_V1 = Gate(Translation + Location + Time + Sensors + Failure + Repair + Bindings + HostEffect + Coherence + AppliedPort)
CANONICAL_SUMMARY:
  one_line:
    - CanonicalCrosswalkAdmissionProtocolV1_0 is the gate that prevents CivOS from becoming branch sprawl by forcing every new entry to declare what it is, where it sits, how it behaves through time, how it is sensed, how it fails, how it repairs, and how it binds into the rest of the system.
```

		

eduKateSG Learning System | Control Tower, Runtime, and Next Routes

This article is one node inside the wider eduKateSG Learning System.

At eduKateSG, we do not treat education as random tips, isolated tuition notes, or one-off exam hacks. We treat learning as a living runtime:

state -> diagnosis -> method -> practice -> correction -> repair -> transfer -> long-term growth

That is why each article is written to do more than answer one question. It should help the reader move into the next correct corridor inside the wider eduKateSG system: understand -> diagnose -> repair -> optimize -> transfer. Your uploaded spine clearly clusters around Education OS, Tuition OS, Civilisation OS, subject learning systems, runtime/control-tower pages, and real-world lattice connectors, so this footer compresses those routes into one reusable ending block.

Start Here

Learning Systems

Runtime and Deep Structure

Real-World Connectors

Subject Runtime Lane

How to Use eduKateSG

If you want the big picture -> start with Education OS and Civilisation OS
If you want subject mastery -> enter Mathematics, English, Vocabulary, or Additional Mathematics
If you want diagnosis and repair -> move into the CivOS Runtime and subject runtime pages
If you want real-life context -> connect learning back to Family OS, Bukit Timah OS, Punggol OS, and Singapore City OS

Why eduKateSG writes articles this way

eduKateSG is not only publishing content.
eduKateSG is building a connected control tower for human learning.

That means each article can function as:

a standalone answer,
a bridge into a wider system,
a diagnostic node,
a repair route,
and a next-step guide for students, parents, tutors, and AI readers.

eduKateSG.LearningSystem.Footer.v1.0

TITLE: eduKateSG Learning System | Control Tower / Runtime / Next Routes

FUNCTION:
This article is one node inside the wider eduKateSG Learning System.
Its job is not only to explain one topic, but to help the reader enter the next correct corridor.

CORE_RUNTIME:
reader_state -> understanding -> diagnosis -> correction -> repair -> optimisation -> transfer -> long_term_growth

CORE_IDEA:
eduKateSG does not treat education as random tips, isolated tuition notes, or one-off exam hacks.
eduKateSG treats learning as a connected runtime across student, parent, tutor, school, family, subject, and civilisation layers.

PRIMARY_ROUTES:
1. First Principles
   - Education OS
   - Tuition OS
   - Civilisation OS
   - How Civilization Works
   - CivOS Runtime Control Tower

2. Subject Systems
   - Mathematics Learning System
   - English Learning System
   - Vocabulary Learning System
   - Additional Mathematics

3. Runtime / Diagnostics / Repair
   - CivOS Runtime Control Tower
   - MathOS Runtime Control Tower
   - MathOS Failure Atlas
   - MathOS Recovery Corridors
   - Human Regenerative Lattice
   - Civilisation Lattice

4. Real-World Connectors
   - Family OS
   - Bukit Timah OS
   - Punggol OS
   - Singapore City OS

READER_CORRIDORS:
IF need == "big picture"
THEN route_to = Education OS + Civilisation OS + How Civilization Works

IF need == "subject mastery"
THEN route_to = Mathematics + English + Vocabulary + Additional Mathematics

IF need == "diagnosis and repair"
THEN route_to = CivOS Runtime + subject runtime pages + failure atlas + recovery corridors

IF need == "real life context"
THEN route_to = Family OS + Bukit Timah OS + Punggol OS + Singapore City OS

CLICKABLE_LINKS:
Education OS:
Education OS | How Education Works — The Regenerative Machine Behind Learning


Tuition OS:
Tuition OS (eduKateOS / CivOS)


Civilisation OS:
Civilisation OS


How Civilization Works:
Civilisation: How Civilisation Actually Works


CivOS Runtime Control Tower:
CivOS Runtime / Control Tower (Compiled Master Spec)


Mathematics Learning System:
The eduKate Mathematics Learning System™


English Learning System:
Learning English System: FENCE™ by eduKateSG


Vocabulary Learning System:
eduKate Vocabulary Learning System


Additional Mathematics 101:
Additional Mathematics 101 (Everything You Need to Know)


Human Regenerative Lattice:
eRCP | Human Regenerative Lattice (HRL)


Civilisation Lattice:
The Operator Physics Keystone


Family OS:
Family OS (Level 0 root node)


Bukit Timah OS:
Bukit Timah OS


Punggol OS:
Punggol OS


Singapore City OS:
Singapore City OS


MathOS Runtime Control Tower:
MathOS Runtime Control Tower v0.1 (Install • Sensors • Fences • Recovery • Directories)


MathOS Failure Atlas:
MathOS Failure Atlas v0.1 (30 Collapse Patterns + Sensors + Truncate/Stitch/Retest)


MathOS Recovery Corridors:
MathOS Recovery Corridors Directory (P0→P3) — Entry Conditions, Steps, Retests, Exit Gates


SHORT_PUBLIC_FOOTER:
This article is part of the wider eduKateSG Learning System.
At eduKateSG, learning is treated as a connected runtime:
understanding -> diagnosis -> correction -> repair -> optimisation -> transfer -> long-term growth.

Start here:
Education OS
Education OS | How Education Works — The Regenerative Machine Behind Learning


Tuition OS
Tuition OS (eduKateOS / CivOS)


Civilisation OS
Civilisation OS


CivOS Runtime Control Tower
CivOS Runtime / Control Tower (Compiled Master Spec)


Mathematics Learning System
The eduKate Mathematics Learning System™


English Learning System
Learning English System: FENCE™ by eduKateSG


Vocabulary Learning System
eduKate Vocabulary Learning System


Family OS
Family OS (Level 0 root node)


Singapore City OS
Singapore City OS


CLOSING_LINE:
A strong article does not end at explanation.
A strong article helps the reader enter the next correct corridor.

TAGS:
eduKateSG
Learning System
Control Tower
Runtime
Education OS
Tuition OS
Civilisation OS
Mathematics
English
Vocabulary
Family OS
Singapore City OS

Start Here:

Canonical Crosswalk Admission Protocol v1.0