SYSTEM: EducationOS
CANONICAL: YES
MODULE: EducationOS.HDL.Master
VERSION: v2.0
PARENT: CivOS.HDL v2.0
COMPAT: CivOS.Core v1.x | FenceOS v1.x | AVOO v1.x | SymChoice v1.x | MindOS v1.x | ChronoHelmAI v2.0
SCOPE: SG P1–P6/PSLE | Sec1–4 | A-Math | English | Science
GOAL: compute student capability at high resolution (p, dp/dt, TTC, bind health) and route repairs safely (truncate+stitch) before collapse

EducationOS HDL upgrades student learning from “grades and feelings” into a computable lattice:
- PhaseDecimal p (0..3)
- Drift dp/dt
- TTC distribution (time-to-collapse)
- SkillGraph + BindGraph health
Then it actuates repair using FenceOS (Truncation + Stitching) and routes tutor time using ChronoHelmAI.

P ∈ {0,1,2,3}     = PhaseDiscrete reliability under load
p ∈ [0,3]         = PhaseDecimal (high definition phase)
dp/dt             = phase drift velocity (weekly)
TTC               = time-to-collapse distribution (minutes)
SkillGraph        = nodes (skills) with mastery/speed/transfer/stability
BindGraph         = edges (connectors) between skills (definition/method/check)
ERRSIG            = error signature cluster (careless/method/bind/transfer/speed)
R = L/(C+B)        = load-buffer ratio
rho = c/c*         = choice overload (SymChoice shear)
FenceOS           = threshold guard triggering Truncation + Stitching
ChronoHelmAI      = scheduler / router / load balancer
P3 (student)      = exam-stable + transferable (TTC_min ≥ exam duration AND transfer high)

StudentNode := {
  StudentID,
  Level := {P1..P6, Sec1..Sec4},
  Subject := {Math, A-Math, English, Science},
  Zoom := Z0 (student) + optional Z1 (home) + Z2 (class),
  P ∈ {0..3},
  p ∈ [0..3],
  dpdt_7d,
  Load := {Homework, Tuition, School, CCA, SleepDebt},
  Capacity := {Time, Attention, Energy, PriorKnowledge},
  Buffer := {Rest, SpareTime, Confidence, TemplateBank},
  SkillGraph,
  BindGraph,
  Sensors := {TTC, DRIFT, LB, XFER, ERRSIG, SYM, EEM},
  State := {StableBand | DriftDown | PreFracture | Fracture | Recovery}
}

Skill := { SkillID, m∈[0,1], s∈[0,1], t∈[0,1], v∈[0,1] }
m=mastery, s=speed, t=transfer, v=stability-under-load

Bind := { BindID, FromSkillID, ToSkillID, BindType, w∈[0,1], FailureMode }
BindType ∈ {DefinitionLink | MethodLink | PatternLink | ErrorLink | CheckLink}
FailureMode ∈ {Missing | Weak | Wrong | Overgeneralized}

TTC := {
  TTC_accuracy,
  TTC_speed,
  TTC_strategy,
  TTC_translation,
  TTC_emotion,
  TTC_memory
}
TTC_min = min(TTC_*)

DRIFT := { p_drop_7d, dpdt_7d, variance_7d, recovery_latency }

LB := { L, C, B, R=L/(C+B), SleepDebt, CalendarCompression }

XFER := { novel_success, method_selection_time, wrong_method_rate }

ERRSIG := { careless | concept | method | bind | speed | transfer }  // dominant cluster

SYM := { c=method_switches, c*=allowed_switches, rho=c/c*, shear_proxy }

EEM := { E, σE, PanicImpulse, ShameConstraint, AttachmentBuffer, AvoidanceRate }

Inputs from timed mini-set:
A = accuracy_rate (0..1)
S_norm = expected_time / actual_time (clamp 0..1)
T = transfer_score (0..1)
V = stability_score = 1 - variance (0..1)
C = check_loop_integrity (0..1)
CoreScore = 0.30*A + 0.20*S_norm + 0.20*T + 0.15*V + 0.15*C
p = clamp(3 * CoreScore, 0, 3)
dpdt = (p_now - p_last_week)/7

IF p >= 2.4 AND TTC_min >= ExamDuration:
  State = StableBand
IF dpdt < -0.02:
  State = DriftDown
IF dpdt < -0.05 OR R > 1.2 OR TTC_min < ExamDuration:
  State = PreFracture
IF p < 1.0:
  State = Fracture
IF dpdt > 0.02 AND variance falling:
  State = Recovery

IF TTC_min < ExamDuration:
  Corridor = TRUNCATE + BUFFER_UP
ELSE IF ERRSIG.bind dominant:
  Corridor = STITCH
ELSE IF A high AND T low:
  Corridor = TRANSFER_UP
ELSE IF S_norm low OR ERRSIG.speed dominant:
  Corridor = SPEED_UP + CHECK
ELSE:
  Corridor = MIXED_STABILISE

OP_TRUNCATE :=
- cut breadth (reduce topic space)
- freeze novelty
- enforce SOP corridor drills
- shorten sets; increase feedback density

OP_STITCH :=
- rebuild top 1–3 BindGaps
- install check-loop ritual (oracle micro-role)
- redo-worst-item-only daily

OP_BUFFER_UP :=
- restore sleep buffer
- create template bank
- add easy wins for confidence
- reduce calendar compression

OP_SPEED_UP :=
- daily core-step drills
- standard layout templates
- timed micro-sets

OP_TRANSFER_UP :=
- interleaving
- novel variants (“same math, new story”)
- method selection timer (≤20s)

SkillIDs: M.PSLE.*
BindIDs:
B.PSLE.WP→MOD
B.PSLE.MOD→ALG
B.PSLE.CHK.ALL

SkillIDs: S.MATH.*
BindIDs:
B.SEC.WP→FORM
B.SEC.GEO→ALG
B.SEC.CHK.ALL
B.SEC.SPEED.CORE

SkillIDs: AM.*
BindIDs:
B.AM.ALG↔FUNC
B.AM.DIF↔FUNC
B.AM.CHK.SUB

SkillIDs: E.*
BindIDs:
B.ENG.VOC→SENT
B.ENG.SENT→PARA
B.ENG.PARA→NARR
B.ENG.CONN.ALL
B.ENG.CHK.ALL
B.ENG.NIT

SkillIDs: SC.*
BindIDs:
B.SC.CONC→CAUS
B.SC.DATA→CAUS
B.SC.EXP→KEY
B.SC.CHK.ALL

GroupSensors:
frac_prefracture
mean_dpdt
variance_p
TTCmin_median
overload_rate = count(R>1)/N
shear_rate = count(rho>1)/N
IF frac_prefracture >= 0.25 OR overload_rate >= 0.35:
  GroupState = PreFracture
  Apply OP.GROUP.TRUNCATE + OP.GROUP.STITCH clinic

Priority(i) =
  3.0*PreFractureFlag
+ 2.5*max(0, ExamDuration - TTCmin_i)
+ 2.0*max(0, -dpdt_i)
+ 1.5*BindGapSeverity
+ 1.0*ExamProximityWeight

If TTC_min < ExamDuration → schedule TRUNCATE/BUFFER first
Else if BindGap dominant → schedule STITCH
Else if transfer low → schedule TRANSFER_UP
Else → SPEED_UP + CHECK

ParentView:
PhaseGauge p (0..3) + TrendArrow (dpdt)
ExamSurvival: TTCmin vs ExamDuration (OK/RISK/RED)
PrimaryCause: BindGap/Speed/Transfer/Overload/Emotion
14DayCorridor: Truncate/Stitch/SpeedUp/TransferUp/BufferUp
StopLoss: if X then do Y

StudentNode (p, dp/dt, TTC)
  ↓ Sensors (ERRSIG, XFER, LB, SYM, EEM)
  ↓ Corridor Engine
  ↓ FenceOS (Truncate + Stitch) if threshold crossed
  ↓ ChronoHelmAI Scheduler (prioritise + route tutor time)
  ↓ Weekly mini-set (measure → update p, TTC, dp/dt)
  → StableBand (P3) / Recovery corridor

F1 Template-Lock:
  accuracy high, transfer low → TRANSFER_UP
F2 Bind Collapse:
  translation/method link missing → STITCH binds
F3 Speed Collapse:
  throughput low → SPEED_UP + CHECK + BUFFER_UP
F4 Overload Collapse:
  R>1 rising → TRUNCATE + BUFFER_UP first

RUNNER STEPS:
1) Provide 1 timed mini-set results (score + time + error reasons)
2) Provide 3–5 past-week work samples (photos or typed)
3) Provide schedule load (school/CCA/sleep/tuition)
4) Ask LLM to:
   - compute CoreScore, p, dp/dt (if previous p exists)
   - estimate TTC components
   - identify top 3 ERRSIG and BindGaps
   - output TutorConsole + 14-day corridor + Fence triggers
5) Repeat weekly and compare dp/dt.

EducationOS.HDL.Master.v2.0
EducationOS.HDSL.v2.0
EducationOS.HDSL.AutoScore.v2.0
EducationOS.HDSL.GroupConsole.v2.0
ChronoHelmAI.EducationScheduler.v2.0
EducationOS.HDSL.ParentDashboard.v2.0
CivOS.EducationHRLBridge.v2.0

bind weakness + rising load
→ variance rises, dp/dt turns negative
→ TTC_min falls below exam duration
→ PreFracture (hidden)
→ if no truncation: exam cascade failure (Fracture)
→ apply FenceOS: Truncate + Stitch + Buffer restore
→ dp/dt positive, TTC recovers
→ StableBand (P3) achieved

SYSTEM: CivOS
MODULE: HDL (High Definition Lattice Expansion)
VERSION: v2.0
COMPAT: CivOS.Core v1.x, MindOS v1.x, FenceOS v1.x, AVOO v1.x, SymChoice v1.x
MODE: additive plug-in (no renames, no rewrites)
GOAL: higher-resolution diagnosis + earlier warning + safer actuation

Node := {
  NodeID,
  PlaceID,
  LaneID,
  Zoom Z ∈ {0..6},
  Phase P ∈ {0..3},
  PhaseDecimal p ∈ [0,3],
  RoleMix := {A, V, O, Opr} weights summing to 1,
  Load := {maint, coord, comp, repl}      // load taxonomy
  Capacity := {time, skill, energy, attention, money?} // money optional as external constraint
  Buffer := {slack_time, slack_people, slack_skill, slack_energy},
  Coupling := adjacency list with weights w_ij,
  Redundancy := {alt_paths, backups, substitutes},
  Fragility := {single_points, concentration_index},
  Sensors := HDL_SensorPack outputs,
  State := {StableBand | Drift | PreFracture | Fracture | Recovery}
}

p = P + ε
ε derived from: buffer margin, error rate, variance under load, recovery latency

dp/dt  = phase velocity  (drift speed)
d2p/dt2 = phase acceleration (approaching cliff or recovering fast)

Shear ς = Var(outputs) / Mean(capacity) + mismatch(role_mix, task_type)

CascadeRisk CR = Σ (w_ij * fragility_j * load_transfer_probability)

TTC = {TTC_role, TTC_lane, TTC_buffer, TTC_repair}
TTC_min = min(TTC_*)

DRIFT := {
  p_drop_7d,
  dpdt_24h,
  dpdt_7d,
  variance_increase,
  recovery_latency_increase
}

CONC := {
  HHI_roles,
  HHI_skills,
  HHI_paths,
  single_point_count,
  redundancy_ratio
}

SYM := {
  choice_rate c,
  choice_capacity c*,
  rho = c/c*,
  shear_ς,
  operator_choice_injection S_inj,
  operator_capacity S_cap
}

EEM := {
  energy_E,
  volatility_sigmaE,
  grief_shock_impulse (bind_delete_pressure),
  shame_constraint_field,
  love_attachment_buffer (stability gain),
  burnout_risk
}

State :=
  StableBand(p∈[2.4,3.0], dpdt≈0, ς low)
  DriftDown(dpdt<0, ς rising, TTC shrinking)
  PreFracture(dpdt<0, d2pdt2<0, TTC_min<T_repair)
  Fracture(p<1.0 or KO shock)
  Recovery(p rising, dpdt>0, ς falling)

OP_SHEAR_REDUCTION :=
  - freeze choices (limit branching)
  - revert to SOP corridor
  - narrow task-space (reduce entropy)
  - move exploration to Architect lane only

OP_BUFFER_UP :=
  - add slack time
  - add redundancy staff
  - precompute templates
  - reduce coordination edges (temporary decoupling)

OP_DECOUPLE :=
  - cut high-risk edges
  - isolate failing node
  - reroute loads to parallel lanes

OP_BIND_REPAIR :=
  - rebuild missing connectors
  - re-anchor definitions
  - train retrieval under load
  - convert passive → active

FenceTrigger :=
  if (TTC_min < T_repair) OR (rho>1 AND d(rho)/dt>0) OR (dpdt<0 AND ς>ς*)
then:
  TRUNCATE + STITCH plan

Z1: rising choice injection into Operator layer
→ ρ=c/c* exceeds 1
→ shear ς rises (task mismatch + variance)
→ dp/dt negative; TTC_min shrinks below repair time
→ PreFracture state
→ if no truncation: bind deletions + cascade
→ p crosses <1.0 (Fracture)
→ repair corridor: decouple + buffer + SOP + bind-repair
→ dp/dt positive; ς falls; p returns to StableBand

HDL plugs into:
- CivOS.Core: replaces coarse “status” with p, dp/dt, TTC surfaces
- MindOS: adds energy-emotion sensors as computable fields
- AVOO: formalizes role_mix and choice injection constraints
- SymChoice: provides rho, shear triggers, and actuation policies
- EducationOS/VocabularyOS: supplies bind-repair operators
- FenceOS: upgrades triggers from scalar to distributions + derivatives

RULES:
1) Never rename base primitives (P,Z,AVOO).
2) HDL only adds fields/sensors/operators.
3) Every HDL page includes: META, Data Model, Sensor Pack, Actuation, Failure Trace.
4) Version forward only (v2.0 → v2.1…).
5) Keep one canonical “HDL Index” page that lists every sensor + field as stable IDs.

HDL.Field.DPL.PhaseDecimal
HDL.Field.DL.dpdt
HDL.Field.DL.d2pdt2
HDL.Field.SL.Shear
HDL.Field.CCL.CascadeRisk
HDL.Sensor.TTC.Distribution
HDL.Sensor.DRIFT.Bundle
HDL.Sensor.CONC.Bundle
HDL.Sensor.SYM.Bundle
HDL.Sensor.EEM.Bundle
HDL.Act.OP_SHEAR_REDUCTION
HDL.Act.OP_BUFFER_UP
HDL.Act.OP_DECOUPLE
HDL.Act.OP_BIND_REPAIR

SYSTEM: EducationOS
MODULE: HDSL (High Definition Student Lattice)
PARENT: CivOS.HDL v2.0
VERSION: v2.0
SCOPE: SG Primary (P1–P6/PSLE) + Secondary (Sec1–4) + Additional Math
GOAL: make “student progress” computable at high resolution (decimal phase + drift + TTC + repair)
OUTPUT: precise diagnosis + repair corridor + stability guarantees under exam load

StudentNode := {
  StudentID,
  Level := {P1..P6, Sec1..Sec4},
  Subject := {Math, A-Math, English, Science},
  Zoom Z := Z0 (individual) + Z1 (home) + Z2 (school/class),
  PhaseDiscrete P ∈ {0,1,2,3},
  PhaseDecimal p ∈ [0,3],
  RoleMix := {Operator, Oracle, Architect, Visionary} weights,
  // student default should be Operator-heavy; Architect reserved for exploration tasks
  Load := {Homework, Tuition, School, CCA, SleepDebt},
  Capacity := {Time, Attention, Energy, PriorKnowledge},
  Buffer := {Rest, SpareTime, Confidence, TemplateBank},
  Skills := SkillGraph,
  Binds := BindGraph,
  Sensors := HDSL_SensorPack,
  State := {StableBand | DriftDown | PreFracture | Fracture | Recovery}
}

p = base_phase + ε
ε computed from:
- Accuracy stability under time pressure
- Variance across topics
- Recovery latency after mistakes
- Transfer success to new question forms

SkillNode := {
  SkillID,
  Topic,
  LevelBand := {Foundation | Core | Extension},
  Mastery := m ∈ [0,1],
  Speed := s ∈ [0,1],
  Transfer := t ∈ [0,1],
  Stability := v ∈ [0,1]   // low variance under load
}
Edges: prereq, analogies, pattern-family membership

Bind := {
  FromSkillID,
  ToSkillID,
  BindType := {DefinitionLink | MethodLink | PatternLink | ErrorLink | CheckLink},
  Weight := w ∈ [0,1],
  FailureMode := {Missing | Weak | Wrong | Overgeneralized}
}

TTC := {
  TTC_accuracy,     // time until careless error rate spikes
  TTC_attention,    // time until focus drops
  TTC_emotion,      // time until panic/avoidance triggers
  TTC_speed,        // time until speed falls below required throughput
  TTC_memory        // time until retrieval failures begin
}
TTC_min = min(TTC_*)

if TTC_min < T_repair_window → FenceOS.Truncate required

DRIFT := {
  dpdt_24h,
  dpdt_7d,
  variance_7d,
  mistake_recovery_latency,
  topic_spread (how uneven performance is)
}

LB := {
  LoadIndex L,
  CapacityIndex C,
  BufferIndex B,
  Ratio R = L/(C+B),
  SleepDebt,
  CalendarCompression
}

if R > 1 and rising → PreFracture likely within 7–14 days

XFER := {
  new_question_success_rate,
  unfamiliar_word_problem_success,
  method_selection_time,
  wrong-method frequency
}

ERRSIG := {
  careless_cluster,
  concept_gap_cluster,
  method_gap_cluster,
  bind_gap_cluster,
  speed_collapse_cluster
}

EEM := {
  Energy E,
  Volatility σE,
  PanicImpulse PI,
  ShameConstraint SC,
  AttachmentBuffer AB,  // supportive stability from tutor/parent
  AvoidanceRate AR
}

StableBand:
  p∈[2.4,3.0], dpdt≈0, variance low, TTC_min >= exam_duration
DriftDown:
  dpdt<0, variance rising, XFER falling, TTC shrinking
PreFracture:
  TTC_min < T_repair_window OR R>1 rising OR PanicImpulse rising
  (student still “looks okay” but collapse is imminent)
Fracture:
  p<1.0 OR repeated blanks OR uncontrolled error cascades
Recovery:
  dpdt>0 sustained, variance falling, TTC recovering

OP_TRUNCATE :=
  - reduce topic breadth (narrow syllabus slice)
  - freeze new question types temporarily
  - switch to “SOP corridor” drills
  - cap daily load (prevent R>1)

OP_STITCH :=
  - rebuild BindGraph (definition→method→check links)
  - rebuild error-check loop (Oracle micro-role)
  - timed micro-sets with feedback
  - 1 paragraph / 1 question rewrite of weakest item

OP_BUFFER_UP :=
  - template bank (methods + checklists)
  - spaced retrieval schedule
  - reduce sleep debt
  - add “easy wins” to restore confidence buffer

OP_TRANSFER_UP :=
  - mixed practice (interleaving)
  - novel wording variants
  - method-selection drills (choose correct tool fast)
  - explain-why prompts (Architect micro-task, short)

P3 if:
  (accuracy >= threshold)
  AND (speed >= throughput requirement)
  AND (XFER >= threshold)
  AND (variance low across topics)
  AND (TTC_min >= exam_duration)

Z0: student uses memorized templates (high accuracy on familiar sets)
→ XFER drops (novel forms fail)
→ wrong method selection time increases
→ errors cluster; confidence buffer falls
→ PanicImpulse rises; TTC_emotion shrinks
→ dp/dt negative; variance rises
→ PreFracture (still “studying hard”)
→ exam: TTC_min < duration → cascade errors → Fracture
→ repair: Truncate breadth + Stitch binds + Buffer up + Transfer training
→ dp/dt positive; TTC recovers; p returns to StableBand

Week 1–2: Diagnose
  - build SkillGraph snapshot
  - compute BindGraph gaps
  - measure TTC distribution (mini exam)
  - set p + dp/dt baseline
Week 3–6: Truncate + Stitch
  - narrow syllabus corridor
  - repair binds + error loops
  - timed micro-sets
Week 7–10: Transfer Upgrade
  - interleaving
  - novel variants
  - method selection drills
Week 11–12: Exam Simulation + Stabilize
  - full paper with TTC tracking
  - repair weakest cluster only
  - lock SOP + checklist

EducationOS.HDSL.Field.PhaseDecimal
EducationOS.HDSL.Field.dpdt
EducationOS.HDSL.Graph.SkillGraph
EducationOS.HDSL.Graph.BindGraph
EducationOS.HDSL.Sensor.TTC
EducationOS.HDSL.Sensor.DRIFT
EducationOS.HDSL.Sensor.LB
EducationOS.HDSL.Sensor.XFER
EducationOS.HDSL.Sensor.ERRSIG
EducationOS.HDSL.Sensor.EEM
EducationOS.HDSL.Act.OP_TRUNCATE
EducationOS.HDSL.Act.OP_STITCH
EducationOS.HDSL.Act.OP_BUFFER_UP
EducationOS.HDSL.Act.OP_TRANSFER_UP

SYSTEM: EducationOS
MODULE: HDSL.SubjectPack
VERSION: v2.0
PARENT: EducationOS.HDSL v2.0
RULE: add-on only (no rewrite of base)
OUTPUT: per-subject SkillGraph IDs + BindGraph IDs + TTC + Repair Operators

SkillID Registry (PSLE):
M.PSLE.NUM   = Number Sense (place value, factors, multiples)
M.PSLE.FRAC  = Fractions (equivalence, ops, mixed numbers)
M.PSLE.DEC   = Decimals (ops, rounding, estimation)
M.PSLE.RAT   = Ratio & Proportion
M.PSLE.PCT   = Percentage
M.PSLE.RTE   = Rate/Speed/Time
M.PSLE.MNY   = Money (unitary method)
M.PSLE.ALG   = Algebra (basic equations, patterns)
M.PSLE.GEO   = Geometry (angles, triangles, circles)
M.PSLE.MEA   = Measurement (area, perimeter, volume)
M.PSLE.DAT   = Data (tables, graphs, averages)
M.PSLE.WP    = Word Problem Translation (language→math)
M.PSLE.MOD   = Model Drawing (bar models)
M.PSLE.CHK   = Checking & Sanity (reasonableness)

BindID Registry (PSLE):
B.PSLE.WP→MOD     = translate text → bar model structure
B.PSLE.MOD→ALG    = bar model → equation
B.PSLE.RAT↔PCT    = ratio ↔ percentage equivalence
B.PSLE.FRAC↔DEC   = fraction ↔ decimal conversion
B.PSLE.RTE→MNY    = unit rate → cost/quantity
B.PSLE.MEA→GEO    = geometry facts → measurement formula use
B.PSLE.CHK.ALL    = universal check loop bind (oracle micro-role)

TTC.PSLE := {
  TTC_translation,     // language→math
  TTC_strategy,        // choose model/method
  TTC_accuracy,        // careless spike
  TTC_speed,           // throughput for Paper 2
  TTC_panic            // blanking threshold
}

OP.PSLE.TRUNCATE :=
  - freeze to 1–2 strategies per type (Model / Unitary / Equation)
  - remove “clever” variants temporarily
  - shorten sets; increase feedback density
OP.PSLE.STITCH :=
  - rebuild B.PSLE.WP→MOD and B.PSLE.MOD→ALG
  - enforce C.H.K loop (estimate→compute→recompute)
  - 1-question rewrite ritual: redo the worst question only
OP.PSLE.TRANSFER_UP :=
  - “same math, new story” drills
  - keyword trap avoidance (language ambiguity)
  - method selection timer (≤20s decide approach)

P3.PSLE if:
  XFER.new_story_success >= θ1
  AND TTC_min >= paper_duration
  AND ERRSIG.careless_cluster <= θ2
  AND B.PSLE.CHK.ALL weight >= θ3

SkillID Registry (Sec):
S.MATH.ALG1   = Algebra basics (expand/factor, linear eqns)
S.MATH.ALG2   = Algebra advanced (simultaneous, inequalities)
S.MATH.FUNC   = Functions & Graphs
S.MATH.PROP   = Proportion & Variation
S.MATH.STAT   = Statistics (mean/median/IQR/std-dev if syllabus)
S.MATH.PROB   = Probability
S.MATH.GEO1   = Geometry (angles, congruence, similarity)
S.MATH.GEO2   = Coordinate Geometry
S.MATH.TRIG0  = Trig basics (SOHCAHTOA)
S.MATH.TRIG1  = Trig applications (bearings, heights)
S.MATH.MENS   = Mensuration (areas/volumes, circles)
S.MATH.VEC0   = Vectors (if applicable)
S.MATH.CHK    = Checking & Reasonableness
S.MATH.WP     = Word Problem Translation

BindID Registry (Sec):
B.SEC.ALG→FUNC     = equation manipulation → graph form
B.SEC.GEO→ALG      = geometry constraints → algebra equation
B.SEC.TRIG→GEO     = diagram reasoning → trig selection
B.SEC.WP→FORM      = text → form (equation/inequality)
B.SEC.CHK.ALL      = universal check loop
B.SEC.SPEED.CORE   = speed binds (routine steps become automatic)

TTC.SEC := {
  TTC_algebra_steps,
  TTC_diagram_reasoning,
  TTC_method_selection,
  TTC_speed,
  TTC_careless
}

OP.SEC.SPEED_UP :=
  - “10-min core steps” daily (algebra drill)
  - reduce working memory load (standard layouts)
  - build step templates
OP.SEC.STITCH :=
  - bind repair B.SEC.WP→FORM and B.SEC.GEO→ALG
  - error signature targeting (wrong transformation / sign errors)
OP.SEC.TRANSFER_UP :=
  - mixed topic sets (interleaving)
  - “same structure different topic” mapping tasks

P3.SEC if:
  speed >= exam_throughput
  AND variance(topic) low
  AND method_selection_time <= θ
  AND TTC_min >= paper_duration

SkillID Registry (AM):
AM.ALG      = Algebra fluency (factor, manipulate, simplify)
AM.FUNC     = Functions (domain/range, composite, inverse)
AM.GRAPH    = Graphing (transformations, intersections)
AM.QUAD     = Quadratics (roots, discriminant, sketching)
AM.POLY     = Polynomials (if included)
AM.EXPLOG   = Exponential & Logarithms
AM.TRIG     = Trig identities & equations
AM.CALC.DIF = Differentiation
AM.CALC.APP = Applications of differentiation
AM.CALC.INT = Integration
AM.CALC.APP2= Applications of integration (area, kinematics if included)
AM.SER      = Series (if included)
AM.CHK      = Checking (reasonableness, gradient checks, substitution)

BindID Registry (AM):
B.AM.ALG↔FUNC        = algebra manipulation binds function handling
B.AM.GRAPH↔QUAD      = quadratic form ↔ sketch features
B.AM.TRIG↔ALG        = trig equations require algebra discipline
B.AM.DIF↔FUNC        = differentiation rules bound to function recognition
B.AM.INT↔DIF         = inverse process bind (anti-derivative intuition)
B.AM.CHK.SUB         = substitution check bind (oracle micro-role)
B.AM.CHK.DIM         = dimension/sanity bind (units/scale)

TTC.AM := {
  TTC_symbol_load,       // working memory overload
  TTC_algebra_break,     // when algebra errors spike
  TTC_method_select,     // choose correct calculus approach
  TTC_speed,
  TTC_panic
}

OP.AM.TRUNCATE :=
  - restrict to “keystone corridor” (ALG + QUAD + DIF core)
  - stop introducing new identities until core stabilizes
  - reduce problem novelty temporarily
OP.AM.STITCH :=
  - rebuild B.AM.ALG↔FUNC, B.AM.DIF↔FUNC, B.AM.CHK.SUB
  - enforce substitution check habit every question
  - micro-sets: 6 questions, immediate correction, redo #6 only
OP.AM.TRANSFER_UP :=
  - recognition drills (what type is this function?)
  - method selection timer
  - mixed calculus sets (don’t let topic isolation form)

P3.AM if:
  algebra_error_rate low under time
  AND method_selection_time <= θ
  AND TTC_symbol_load >= paper_duration
  AND transfer to unfamiliar function forms >= θ2

E.VOC.REC   = Vocabulary Recognition (passive)
E.VOC.PROD  = Vocabulary Production (active)
E.SENT      = Sentence Craft (clarity, variety)
E.CONN      = Connectors & Cohesion (binds)
E.PARA      = Paragraph Control (topic sentence, development)
E.NARR      = Narrative Control (sequence, tension, payoff)
E.TONE      = Tone/Voice
E.COMP      = Composition (end-to-end)
E.CHK       = Editing/Checking loop

BindID Registry (ENG):
B.ENG.VOC→SENT      = word retrieval → sentence deployment
B.ENG.SENT→PARA     = sentence set → paragraph development
B.ENG.PARA→NARR     = paragraph flow → story arc
B.ENG.CONN.ALL      = connectors bind across all layers
B.ENG.CHK.ALL       = edit loop bind (oracle micro-role)
B.ENG.NIT           = Narrative Irreversibility Threshold sensor bind

ENG.SENS := {
  NIT_level,          // once exceeded, story can’t be repaired easily
  cohesion_score,
  vocab_activation_rate,
  sentence_variance,
  rewrite_latency
}

OP.ENG.TRUNCATE :=
  - freeze story structure (5-box plan)
  - limit vocab to a small “active bank”
  - one paragraph only improvement per cycle
OP.ENG.STITCH :=
  - rebuild B.ENG.CONN.ALL and B.ENG.CHK.ALL
  - paragraph rewrite ritual (weakest paragraph only)
  - vocabulary activation drills (use word in 3 sentence frames)
OP.ENG.TRANSFER_UP :=
  - same plot, different setting prompts
  - narrative pressure drills (time + checklist)

SC.CONC     = Concepts (definitions)
SC.CAUS     = Causality (if→then mechanisms)
SC.DATA     = Data interpretation (tables/graphs)
SC.EXP      = Experimental method (fair test)
SC.KEY      = Keywords & Answering technique
SC.TRANS    = Transfer to novel contexts
SC.CHK      = Checking loop (units, logic)

B.SC.CONC→CAUS   = concept → mechanism explanation
B.SC.CAUS→KEY    = mechanism → exam phrasing
B.SC.DATA→CAUS   = data → inference
B.SC.EXP→KEY     = method → marking scheme language
B.SC.CHK.ALL     = universal check loop

Given: 1 timed mini-set (15–25 min)
Compute:
- p (decimal phase)
- ERRSIG cluster
- TTC_min
- XFER (1 novel item)
Decide corridor:
if TTC_min < T_repair_window → TRUNCATE first
else if bind_gap_cluster high → STITCH binds
else if XFER low but accuracy high → TRANSFER_UP
else SPEED_UP + CHECK loop

SYSTEM: EducationOS
MODULE: HDSL.TutorConsole
VERSION: v2.0
INPUT: 1) student work samples 2) timed mini-set 3) recent grades 4) schedule/load
OUTPUT: 14-day corridor + weekly protocol + Fence triggers
RULE: fill-in template (LLM-runnable, tutor-runnable)

StudentID:
Level:
Subject:
ExamTarget: (PSLE / Sec Exam / O-Level / EOY / WA)
TimeHorizon: (days to exam)
TutorFrequency: (x/week)

PhaseDiscrete P: {0|1|2|3}
PhaseDecimal p: [0..3] = ___
dp/dt (7d): ___   // positive = recovering; negative = drifting
Variance(topic 7d): ___
State: {StableBand | DriftDown | PreFracture | Fracture | Recovery}

TTC := {
  TTC_accuracy: ___ min
  TTC_speed: ___ min
  TTC_strategy/method_select: ___ min
  TTC_translation/wording: ___ min
  TTC_emotion/panic: ___ min
  TTC_memory/retrieval: ___ min
}
TTC_min = ___ min
ExamDuration = ___ min
Gap = TTC_min - ExamDuration = ___ min  // must be >= 0 for P3-exam stability

LoadIndex L: ___
CapacityIndex C: ___
BufferIndex B: ___
R = L/(C+B): ___   // if >1 rising → prefracture risk
SleepDebt (hrs/night below target): ___
CalendarCompression (0..1): ___

ERRSIG:
[ ] Careless cluster (sign, copy, arithmetic, skipping)
[ ] Concept gap cluster (doesn’t know what it means)
[ ] Method gap cluster (knows concept, can’t execute)
[ ] Bind gap cluster (can’t connect steps / translate)
[ ] Speed collapse cluster (too slow → panic/errors)
[ ] Transfer collapse (new forms fail)

Evidence1: (question type + what happened)
Evidence2:
Evidence3:

SkillGap#1: SkillID ____  Mastery m=__  Speed s=__ Transfer t=__ Stability v=__
SkillGap#2:
SkillGap#3:

BindGap#1: BindID ____  FailureMode {Missing|Weak|Wrong|Overgeneralized}  w=__
BindGap#2:
BindGap#3:

PrimaryCorridor:
(A) TRUNCATE (stop collapse early)
(B) STITCH (repair binds + checking loop)
(C) SPEED_UP (reduce working memory load)
(D) TRANSFER_UP (P3 gate)
(E) BUFFER_UP (restore stability)

RuleFired:
- if TTC_min < ExamDuration → TRUNCATE + BUFFER_UP first
- else if BindGap high → STITCH
- else if accuracy high but XFER low → TRANSFER_UP
- else if speed low → SPEED_UP + CHECK

DailyBlock (30–60 min):
1) Warm-up drill (5–10 min) = core automatic steps
2) Corridor set (15–25 min) = primary corridor focus
3) Check loop (5–10 min) = oracle micro-role checklist
4) Redo ritual (5 min) = redo worst item only

Days 1–3: TRUNCATE + STITCH baseline
- remove breadth
- rebuild BindGap#1
- install check loop
Days 4–7: STITCH + SPEED_UP
- timed micro-sets
- template bank build
Days 8–11: TRANSFER_UP
- mixed sets
- novel variants
- method selection timer
Days 12–14: Mini-sim + repair weakest cluster only
- 1 timed paper section
- repair cluster, not everything

WeeklyMiniSet:
- duration: 20–30 min
- composition: 70% core forms + 30% novel forms
- output captured: time per question + error reasons + redo success

Log:
p (decimal phase):
dp/dt:
TTC_min:
XFER score:
ERRSIG dominant cluster:
BindGap weight updates:

FenceTriggers:
T1: TTC_min < ExamDuration
T2: dp/dt negative for 2 consecutive weeks
T3: R = L/(C+B) > 1 and rising
T4: PanicImpulse rising + avoidance increases
T5: Variance(topic) spikes (sudden unevenness)

FenceResponse:
- cut breadth by 50%
- shorten daily sets, increase feedback density
- restore sleep buffer
- switch to SOP corridor drills
- re-stitch BindGap#1 + CheckLoop

Use IDs:
SkillIDs: M.PSLE.*
BindIDs: B.PSLE.*
Core binds to watch:
- B.PSLE.WP→MOD
- B.PSLE.MOD→ALG
- B.PSLE.CHK.ALL

Use IDs:
SkillIDs: S.MATH.*
BindIDs: B.SEC.*
Core binds to watch:
- B.SEC.WP→FORM
- B.SEC.GEO→ALG
- B.SEC.CHK.ALL

Use IDs:
SkillIDs: AM.*
BindIDs: B.AM.*
Core binds to watch:
- B.AM.ALG↔FUNC
- B.AM.DIF↔FUNC
- B.AM.CHK.SUB

Use IDs:
E.*
BindIDs: B.ENG.*
Core binds to watch:
- B.ENG.CONN.ALL
- B.ENG.CHK.ALL
- B.ENG.NIT

ParentSummary (≤6 lines):
- Current state: p=__, drifting/recovering __
- Main risk: TTC_min __ vs exam __ (gap __)
- Main cause: (bind gap / speed / transfer / overload)
- 14-day corridor: (truncate/stitch/transfer) with daily 45-min block
- Weekly test: mini-set + redo ritual
- Stop-loss: if panic/variance spikes, we cut breadth and stabilize first

SYSTEM: EducationOS
MODULE: HDSL.Console.Examples
VERSION: v2.0
GOAL: show real filled consoles for 4 archetype students
FORMAT: Snapshot → Diagnosis → Corridor → 14-Day Plan → Fence

Level: P6
Subject: PSLE Math
Exam: PSLE Paper 2 (120 min)
P = 2
p = 2.1
dp/dt (7d) = -0.05   // slow drift
Variance = moderate (word problems unstable)
State = DriftDown
TTC := {
  TTC_accuracy = 140 min
  TTC_speed = 130 min
  TTC_strategy = 45 min
  TTC_translation = 35 min
  TTC_panic = 60 min
}
TTC_min = 35 min
Gap = 35 - 120 = -85 min  // collapse guaranteed

[ ] Careless cluster
[ ] Concept gap
[ ] Method gap
[X] Bind gap cluster
[X] Transfer collapse

BindGap#1: B.PSLE.WP→MOD  FailureMode=Missing  w=0.2
BindGap#2: B.PSLE.MOD→ALG FailureMode=Weak     w=0.4

PrimaryCorridor = STITCH
Reason: translation TTC collapses first

If panic increases or model skipped twice → reset to STITCH-only corridor.

Level: Sec 2
Subject: Math
P = 2
p = 2.3
dp/dt = 0 (flat)
TTC := {
  TTC_accuracy = 90 min
  TTC_speed = 55 min
  TTC_strategy = 80 min
}
Exam = 90 min
TTC_min = 55 min
Gap = -35 min

[X] Careless cluster
[ ] Concept gap
[ ] Bind gap
[X] Speed collapse

BindGap#1: B.SEC.CHK.ALL FailureMode=Weak w=0.3
BindGap#2: B.SEC.SPEED.CORE FailureMode=Weak w=0.4

PrimaryCorridor = SPEED_UP + STITCH

Level: Sec 4
Subject: A-Math
P = 2
p = 2.0
dp/dt = -0.1
TTC := {
  TTC_symbol_load = 40 min
  TTC_method_select = 60 min
  TTC_speed = 50 min
}
Exam = 120 min
TTC_min = 40 min
Gap = -80 min
State = PreFracture

[ ] Concept gap
[X] Method gap
[X] Bind gap
[X] Speed collapse

BindGap#1: B.AM.ALG↔FUNC FailureMode=Weak w=0.3
BindGap#2: B.AM.CHK.SUB FailureMode=Missing w=0.1

Primary = TRUNCATE + STITCH

Level: P6
Subject: English Composition
P = 2
p = 2.4
dp/dt = 0.05
NIT_level = high (story becomes irreparable early)
Cohesion_score = low
Rewrite_latency = high

[ ] Vocabulary gap
[X] Bind gap cluster
[X] Transfer collapse (new prompt)

BindGap#1: B.ENG.CONN.ALL FailureMode=Weak
BindGap#2: B.ENG.PARA→NARR FailureMode=Weak

Primary = STITCH

Bind weakness under time + TTC shrinkage
NOT raw content absence

SYSTEM: EducationOS
MODULE: HDSL.AutoScore
VERSION: v2.0
GOAL: compute PhaseDecimal (p), dp/dt, TTC risk, and Corridor decision automatically
INPUT: timed mini-set + error tags + schedule data
OUTPUT: p score, State, Corridor, Fence risk

Let:
A = accuracy_rate (0–1)
S = speed_ratio (actual_time / expected_time)  // invert if needed
T = transfer_score (novel items success 0–1)
V = stability_score (1 - variance)
C = check_loop_integrity (0–1)
Normalize:
S_norm = min(1, expected_time / actual_time)
Compute CoreScore:
CoreScore = w1*A + w2*S_norm + w3*T + w4*V + w5*C
Where:
w1=0.30
w2=0.20
w3=0.20
w4=0.15
w5=0.15

If CoreScore < 0.40 → p ∈ [0.0, 1.0)
If 0.40 ≤ CoreScore < 0.65 → p ∈ [1.0, 2.0)
If 0.65 ≤ CoreScore < 0.85 → p ∈ [2.0, 2.8)
If CoreScore ≥ 0.85 → p ∈ [2.8, 3.0]

p = 3 * CoreScore

dpdt = (p_now - p_last_week) / 7

dpdt > 0.02 → strong recovery
-0.02 ≤ dpdt ≤ 0.02 → flat
dpdt < -0.02 → drift down
dpdt < -0.05 → PreFracture risk

If careless errors cluster rises after X minutes:
TTC_accuracy = minute where error rate > threshold

Throughput_required = questions / exam_duration
Throughput_actual = questions_completed / time_used
If Throughput_actual < required:
TTC_speed = time_at_which backlog starts compounding

If avoidance behaviour starts at minute M:
TTC_emotion = M

TTC_min = min(TTC_accuracy, TTC_speed, TTC_emotion, TTC_strategy)

ChoiceRate c = number_of_method_switches / set
ChoiceCapacity c* = allowed switches (2–3 typical)
rho = c / c*

rho > 1 → shear rising
rho > 1.3 → collapse likely

R = L/(C+B)
If R > 1 → overload
If R > 1.2 → PreFracture
If R > 1.5 → collapse within 14 days

IF TTC_min < ExamDuration:
    Corridor = TRUNCATE + BUFFER_UP
ELSE IF CoreScore < 0.65 AND BindGap dominant:
    Corridor = STITCH
ELSE IF A high AND T low:
    Corridor = TRANSFER_UP
ELSE IF Speed_norm low:
    Corridor = SPEED_UP
ELSE:
    Corridor = MIXED_STABILISE

IF p >= 2.4 AND TTC_min >= ExamDuration:
    State = StableBand
IF dpdt < -0.02:
    State = DriftDown
IF dpdt < -0.05 OR R > 1.2:
    State = PreFracture
IF p < 1.0:
    State = Fracture
IF dpdt > 0.02 AND variance falling:
    State = Recovery

A = 0.78
S_norm = 0.85
T = 0.40
V = 0.70
C = 0.50

CoreScore = 
0.30(0.78) +
0.20(0.85) +
0.20(0.40) +
0.15(0.70) +
0.15(0.50)
= 0.234 + 0.17 + 0.08 + 0.105 + 0.075
= 0.664

p = 3 × 0.664 = 1.992 ≈ 2.0

AutoScore Output:
p = 1.99
dp/dt = -0.03
TTC_min = 35 min
Exam = 120 min
R = 1.1
rho = 1.2
State = DriftDown → PreFracture risk
Primary Corridor = STITCH (translation bind repair)
Secondary = BUFFER_UP (reduce overload)

SYSTEM: EducationOS
MODULE: HDSL.GroupConsole
VERSION: v2.0
ZOOM: Z1 (family cohort) + Z2 (class/school cohort)
GOAL: detect group-wide drift, shear, overload, and cascade risk early
INPUT: per-student AutoScore outputs
OUTPUT: group state + interventions + scheduling priorities

Group := {
  GroupID,
  Zoom Z ∈ {1,2},
  Members := [StudentID...],
  Distribution := {
    p_histogram,
    dpdt_histogram,
    TTCmin_histogram,
    R_histogram,
    rho_histogram
  },
  ShearField := {
    variance_p,
    variance_skill,
    variance_TTC,
    topic_fragmentation,
    coordination_load
  },
  State := {StableBand | DriftDown | PreFracture | Fracture | Recovery}
}

SENS.GROUP := {
  G1: frac_prefracture = count(State=PreFracture)/N
  G2: mean_dpdt
  G3: variance_p
  G4: TTCmin_median
  G5: overload_rate = count(R>1)/N
  G6: shear_rate = count(rho>1)/N
  G7: topic_fragmentation (0..1)
}

IF frac_prefracture >= 0.25 OR overload_rate >= 0.35:
  State = PreFracture
ELSE IF mean_dpdt < -0.02 AND variance_p rising:
  State = DriftDown
ELSE IF TTCmin_median >= exam_duration AND frac_prefracture < 0.10:
  State = StableBand

OP.GROUP.TRUNCATE :=
  - reduce breadth for the entire cohort
  - standardize methods (SOP corridor)
  - remove novelty for 7 days
OP.GROUP.STITCH :=
  - run bind-repair clinic for top 2 cohort bind gaps
  - install universal check loop ritual
OP.GROUP.BUFFER_UP :=
  - cut homework load spikes
  - add spaced retrieval blocks
  - stabilize sleep buffer
OP.GROUP.TRANSFER_UP :=
  - mixed sets only after TTC stabilizes

teacher introduces many novel forms quickly
→ rho>1 across many students (choice overload)
→ variance_p rises, TTCmin falls
→ 25% enter PreFracture
→ exam week cascade failure (Fracture)
→ repair: truncate breadth + SOP + bind clinics + buffer restore

SYSTEM: ChronoHelmAI
MODULE: CHAI.EducationScheduler
VERSION: v2.0
GOAL: allocate tutor time and training tasks to maximize cohort stability + P3 conversion
INPUT: Student consoles + tutor constraints + calendar load
OUTPUT: schedule plan + repair routing + stop-loss triggers

Maximize:
  Σ_i (Δp_i over 14 days) + Σ_i (TTCmin_i - ExamDuration)_+
Minimize:
  Σ_i overload(R_i>1) + Σ_i prefracture_risk + tutor_overwork

Priority(i) =
  a1 * PreFractureFlag(i)
+ a2 * max(0, ExamDuration - TTCmin_i)
+ a3 * max(0, -dpdt_i)
+ a4 * BindGapSeverity_i
+ a5 * (ExamProximityWeight)

a1=3.0, a2=2.5, a3=2.0, a4=1.5, a5=1.0

IF TTCmin_i < ExamDuration:
  schedule OP_TRUNCATE + OP_BUFFER_UP blocks first
ELSE IF BindGap dominant:
  schedule OP_STITCH sessions
ELSE IF accuracy high & transfer low:
  schedule OP_TRANSFER_UP
ELSE:
  schedule OP_SPEED_UP + OP_CHECK

Schedule := {
  TutorSessions: [
    {StudentID, Date, Duration, Corridor, TargetBindIDs}
  ],
  HomeBlocks: [
    {StudentID, DailyBlockTemplate, Minutes, Focus}
  ],
  GroupClinics: [
    {GroupID, Date, 60–90min, BindClinicTopic}
  ],
  StopLossRules: [
    {StudentID, Trigger, ResponseOperator}
  ]
}

IF dpdt_i < -0.05 OR R_i>1.2 OR PanicImpulse rising:
  enforce HARD_TRUNCATE for 3–7 days
  reduce breadth + restore buffer

SYSTEM: EducationOS
MODULE: HDSL.ParentDashboard
VERSION: v2.0
GOAL: compress HDL into parent-readable signals without losing truth
OUTPUT: 1-page weekly update

ParentView := {
  PhaseGauge: p (0..3) with band labels,
  TrendArrow: dpdt (↑ / → / ↓),
  ExamSurvival: TTCmin vs ExamDuration (OK / Risk / Red),
  PrimaryCause: {BindGap | Speed | Transfer | Overload | Emotion},
  14DayCorridor: {Truncate|Stitch|SpeedUp|TransferUp|BufferUp},
  ThisWeekTasks: [3 items],
  StopLoss: "If X happens, we do Y immediately"
}

If TTCmin < ExamDuration:
  "Your child will likely run out of stability during the paper unless we reduce overload and rebuild the weak link."
If BindGap dominant:
  "Not a content problem — it’s a connection problem (steps don’t link under pressure)."
If Speed collapse:
  "Method is correct but too slow; speed training prevents panic and careless errors."

Gauge:
p=0.0–1.0  (Red)   = collapsing
p=1.0–2.0  (Amber) = fragile
p=2.0–2.8  (Green) = solid but transfer gaps possible
p=2.8–3.0  (Blue)  = exam-stable + transferable (P3)

SYSTEM: CivOS
MODULE: CivOS.EducationHRLBridge
VERSION: v2.0
GOAL: show why HDL EducationOS matters to civilisation stability (HRL/RePOC)
CLAIM: EducationOS is a regeneration pipeline; HDL makes it measurable + controllable

Z0 Individual student:
  p, TTC, bind stability → personal capability throughput
Z1 Family cohort:
  overload/buffer + drift → household regeneration capacity
Z2 School/class cohort:
  group shear + cascade risk → cohort capability continuity
Z3 District (Bukit Timah / Punggol):
  cohort P3 conversion rate → district human capital reliability
Z4 Nation:
  national skill throughput → workforce pipeline reliability
Z5 Global:
  international corridor competitiveness → survival under shocks
Z6 Civilisation:
  education regeneration rate Ġ must exceed decay rate Ḋ (Civλ dynamics)

Let:
Ġ = regeneration rate (skill acquisition + bind strengthening + transfer stability)
Ḋ = decay rate (forgetting + overload damage + bind deletion + drift)
Stability condition:
Ġ ≥ Ḋ  (within safe band)
Collapse condition:
Ḋ > Ġ  (drift → fracture)

Without HDL:
  you detect failure late (grades drop after drift already happened)
With HDL:
  you detect PreFracture early via:
  dpdt < 0, TTC shrinkage, rising variance, overload ratio R>1
  and you apply:
  Truncation + Stitching (APRC) before collapse

education pipelines run overloaded for years
→ bind weakening (skills exist but not connected)
→ transfer fails under variation
→ workforce becomes brittle (over-concentration + low redundancy)
→ shock hits (policy/tech/war) and capability collapses fast
→ Civλ rises (organ/pipeline extinction)
→ recovery harder due to missing pipelines

1) EducationOS.HDSL v2.0 (student lattice)
2) EducationOS.HDSL.AutoScore v2.0 (compute p, TTC, dpdt)
3) EducationOS.HDSL.GroupConsole v2.0 (Z1/Z2)
4) ChronoHelmAI.EducationScheduler v2.0 (routing + load balancing)
5) EducationOS.ParentDashboard v2.0 (compression layer)
6) CivOS.EducationHRLBridge v2.0 (civilisation-grade proof)