Full Tutorial Runtime Specification
Master Integrated Stack in Full Almost Code
Official anchor first. Cambridge currently lists Cambridge IGCSE Mathematics (0580) as an active standalone qualification with both 2025–2027 and 2028–2030 syllabus windows on its qualification page. Cambridge also publishes Cambridge IGCSE (9–1) Mathematics (0980) separately, and that page states it is available only in a limited number of administrative zones. (cambridgeinternational.org)
For Cambridge 0580, the official structure remains Core and Extended routes, with Paper 1 + Paper 3 for Core and Paper 2 + Paper 4 for Extended; Papers 1 and 2 are non-calculator, while Papers 3 and 4 are calculator papers. The syllabus content is organised into nine topic areas. (cambridgeinternational.org)
For Pearson Edexcel International GCSE Mathematics A (4MA1), the official specification identifies it as a linear qualification with two papers per tier, and the published specification includes the paper codes 4MA1/1F, 4MA1/2F, 4MA1/1H, 4MA1/2H plus formula sheet appendices. Pearson’s current 2025/26 International GCSE information manual also lists active entry variants including 4MA1 H, 4MA1 FR, and 4MA1 HR. (qualifications.pearson.com)
Everything below is the eduKateSG runtime layer. It is an interpretive tutorial-control system built on top of the official qualification structures above.
0. Meta Lock
“`text id=”51001″
DOC.NAME = “IGCSE Mathematics Tutorial by eduKateSG v9.0”
DOC.TYPE = “Full Tutorial Runtime Specification”
DOC.MODE = “Master Integrated Stack”
DOC.DEFAULT_BINDING = “Cambridge 0580”
DOC.COMPATIBILITY = [“Cambridge 0980”, “Pearson 4MA1”]
DOC.PURPOSE = “Fuse official board anchor, packet system, forms, runbook, control panel, and decision rules into one master runtime”
DOC.BOUNDARY = “Official board structure remains upstream of all eduKateSG tutorial routing”
DOC.PRIMARY_OUTCOME = “Reduced randomness in diagnosis, lesson design, packet assignment, review, and route decisions”
---## 1. Master Thesis
text id=”51002″
MASTER.THESIS = “IGCSE Mathematics tutorial is not chapter-help only. It is a board-bound runtime that reads student state, identifies repeated failure mechanisms, assigns the right packet, runs controlled interventions, and reviews whether the route is working.”
MASTER.CORE_RULES = {
R1: “Board first”,
R2: “Tier first”,
R3: “Floor before speed”,
R4: “Repair before transfer”,
R5: “Transfer before confidence claims”,
R6: “Paper-mode matters”,
R7: “Mocks must change routing”,
R8: “Tier review is structural, not emotional”
}
---## 2. Official Binding Layer
text id=”51003″
OFFICIAL.BINDING = {
CAMBRIDGE_0580: {
board: “Cambridge”,
code: “0580”,
tiers: [“Core”, “Extended”],
core_papers: [“Paper 1”, “Paper 3”],
extended_papers: [“Paper 2”, “Paper 4”],
paper_modes: {
Paper1: “Non-Calculator”,
Paper2: “Non-Calculator”,
Paper3: “Calculator”,
Paper4: “Calculator”
},
topic_areas: [
“Number”,
“Algebra and graphs”,
“Coordinate geometry”,
“Geometry”,
“Mensuration”,
“Trigonometry”,
“Transformations and vectors”,
“Probability”,
“Statistics”
]
},
CAMBRIDGE_0980: {
board: “Cambridge”,
code: “0980”,
status: “Separate qualification object”
},
PEARSON_4MA1: {
board: “Pearson”,
code: “4MA1”,
tiers: [“Foundation”, “Higher”],
structure: “Linear”,
papers_per_tier: 2,
paper_codes: [“1F”, “2F”, “1H”, “2H”],
formula_sheet: true
}
}
---## 3. Runtime Scope Boundary
text id=”51004″
RUNTIME.SCOPE = {
official_layer: [
“board identity”,
“tier identity”,
“paper structure”,
“topic topology”
],
edukate_layer: [
“diagnosis”,
“classification”,
“packet assignment”,
“lesson runtime”,
“homework prescription”,
“mock conditioning”,
“tier review logic”,
“control tower”
],
non_claims: [
“This runtime does not replace official syllabus documents.”,
“This runtime does not guarantee grade outcomes.”,
“This runtime is a tutorial control system, not an exam-board authority.”
]
}
---## 4. System Architecture
text id=”51005″
SYSTEM.ARCHITECTURE = {
INPUT_LAYER: [
“board”,
“tier”,
“recent scores”,
“student narrative”,
“parent narrative”,
“rapid screen”,
“diagnostic forms”,
“mock scripts”,
“homework evidence”
],
PROCESS_LAYER: [
“state read”,
“error coding”,
“profile classification”,
“packet routing”,
“lesson intervention”,
“review cycle”
],
OUTPUT_LAYER: [
“active packets”,
“lesson plan”,
“homework plan”,
“review decision”,
“route decision”,
“tier decision when needed”
]
}
---## 5. Master Runtime Object
text id=”51006″
IGCSE.TUTORIAL.RUNTIME = {
board_binding: “”,
tier_binding: “”,
student_state: {},
active_profile: “”,
active_errors: [],
dominant_engine: “”,
active_packets: [],
paper_mode_risk: “”,
current_4week_route: {},
mock_cycle_state: “”,
tier_review_state: “”,
next_action: “”
}
---## 6. Student State Model
text id=”51007″
STUDENT.STATE = {
identity: {
student_id: “”,
student_name: “”,
board: “”,
qualification_code: “”,
tier: “”
},
capability_state: {
number: “”,
algebra: “”,
graphs: “”,
geometry: “”,
measure_trig: “”,
data: “”,
mark_capture: “”,
endurance: “”
},
regulation_state: {
confidence: “”,
stamina: “”,
retrieval_speed: “”,
error_recovery: “”
},
paper_mode_state: {
noncalc_risk: “”,
calc_risk: “”
},
dominant_error_codes: [],
likely_profile_type: “”,
route_hypothesis: “”,
next_review_date: “”
}
---## 7. Phase Model
text id=”51008″
PHASE.MODEL = {
P0: “Cannot reliably execute basic syllabus actions”,
P1: “Recognises familiar work but breaks often”,
P2: “Can execute single-topic tasks with support”,
P3: “Can execute mixed exam tasks with usable stability”,
P4: “Can self-correct, pace, and preserve marks under pressure”
}
TARGET.PHASE = {
Cambridge_Core: “P2.5 to P3”,
Cambridge_Extended: “P3 to P4”,
Pearson_Foundation: “P2.5 to P3”,
Pearson_Higher: “P3 to P4”
}
---## 8. Engine Stack
text id=”51009″
ENGINE.STACK = {
E1_NUMBER: {
focus: “quantity control”,
break_type: “arithmetic leakage”
},
E2_ALGEBRA: {
focus: “symbol legality”,
break_type: “sign and structure drift”
},
E3_GRAPHS: {
focus: “visual-symbol translation”,
break_type: “graph feature blindness”
},
E4_GEOMETRY: {
focus: “property-led reasoning”,
break_type: “diagram panic or misread”
},
E5_MEASURE_TRIG: {
focus: “formula-shape-angle binding”,
break_type: “wrong relation or unit/formula loss”
},
E6_DATA: {
focus: “representation and inference”,
break_type: “read-without-understanding”
},
E7_MARK_CAPTURE: {
focus: “visible reasoning and output discipline”,
break_type: “method lost to presentation”
},
E8_ENDURANCE: {
focus: “stability across time and pressure”,
break_type: “late-paper collapse”
}
}
---## 9. Error Taxonomy
text id=”51010″
ERROR.REGISTRY = {
ER01: “Fraction instability”,
ER02: “Decimal-percent instability”,
ER03: “Ratio/proportion mismatch”,
ER04: “Negative sign drift”,
ER05: “Bracket corruption”,
ER06: “Rearrangement failure”,
ER07: “Graph feature blindness”,
ER08: “Gradient/intercept confusion”,
ER09: “Angle property misread”,
ER10: “Diagram panic”,
ER11: “Formula retrieval failure”,
ER12: “Unit loss”,
ER13: “Wrong method choice”,
ER14: “Premature rounding”,
ER15: “Invisible working”,
ER16: “Calculator setup or mode error”,
ER17: “Late-paper fatigue”,
ER18: “Confidence collapse after one break”
}
---## 10. Student Profile Types
text id=”51011″
PROFILE.TYPES = {
SP1_Fragile_Foundation,
SP2_Symbol_Drifter,
SP3_Visual_Collapser,
SP4_False_Safe,
SP5_Calculator_Dependent,
SP6_Time_Collapser,
SP7_Mark_Leaker,
SP8_Anxious_Knower
}
---## 11. Diagnostic Instrument Layer
text id=”51012″
DIAGNOSTIC.INSTRUMENTS = {
D01: “Master Intake Form”,
D02: “Rapid Screen Form”,
D03: “Engine Heatmap”,
D04: “Error Coding Sheet”,
D05: “Paper-Mode Risk Form”,
D06: “Tier Review Form”,
D07: “Mock Postmortem Form”,
D08: “Student Profile Sheet”,
D09: “Packet Recommendation Matrix”,
D10: “Tutor Session Log”,
D11: “4-Week Route Planner”,
D12: “Parent Summary Slip”,
D13: “One-Page Diagnostic Output”,
D14: “Packet Assignment Sheet”,
D15: “Homework Prescription”,
D16: “Lesson Runtime Template”,
D17: “Review Meeting Sheet”,
D18: “Control Panel Minimal”,
D19: “Blank Packet Template”,
D20: “Blank Student-Type Template”
}
---## 12. Diagnostic Sequence
text id=”51013″
DIAGNOSTIC.SEQUENCE = [
“Confirm board”,
“Confirm tier”,
“Run intake”,
“Run rapid screen”,
“Score engine heatmap”,
“Code repeated errors”,
“Read paper-mode risk”,
“Classify student profile”,
“Name most expensive repeated error”,
“Assign packets”
]
---## 13. Packet System Layer
text id=”51014″
PACKET.SYSTEM = {
namespace_root: “IGCSE.PKT”,
families: {
E: “Entry”,
R: “Repair”,
T: “Transfer”,
P: “PaperMode”,
M: “MarkCapture”,
X: “MockEndurance”,
Y: “MemoryRecall”
},
packet_limit: “3 active packets maximum”,
exception: “final pre-exam conditioning may temporarily exceed 3”,
packet_object = {
packet_id: “”,
packet_title: “”,
family: “”,
engine: “”,
purpose: “”,
entry_trigger: [],
success_criteria: [],
exit_rule: “”,
follow_on_packet: []
}
}
---## 14. Canonical Packet Families
text id=”51015″
PACKET.CANON = {
ENTRY: [
“IGCSE.PKT.E.MIX.00.01”,
“IGCSE.PKT.E.RC.00.02”
],
REPAIR: [
“IGCSE.PKT.R.NUM.01.01”,
“IGCSE.PKT.R.NUM.01.02”,
“IGCSE.PKT.R.ALG.01.01”,
“IGCSE.PKT.R.ALG.01.02”,
“IGCSE.PKT.R.ALG.02.03”,
“IGCSE.PKT.R.GRF.01.01”,
“IGCSE.PKT.R.GRF.02.02”,
“IGCSE.PKT.R.GEO.01.01”,
“IGCSE.PKT.R.GEO.02.02”,
“IGCSE.PKT.R.MTR.01.01”,
“IGCSE.PKT.R.MTR.02.02”,
“IGCSE.PKT.R.MTR.03.03”,
“IGCSE.PKT.R.DAT.01.01”,
“IGCSE.PKT.R.DAT.02.02”
],
TRANSFER: [
“IGCSE.PKT.T.MIX.01.01”,
“IGCSE.PKT.T.MIX.02.02”
],
PAPERMODE: [
“IGCSE.PKT.P.NC.01.01”,
“IGCSE.PKT.P.NC.02.02”,
“IGCSE.PKT.P.CC.01.01”
],
MARKCAPTURE: [
“IGCSE.PKT.M.PR.01.01”,
“IGCSE.PKT.M.PR.01.02”
],
MOCK_ENDURANCE: [
“IGCSE.PKT.X.EN.01.01”,
“IGCSE.PKT.X.EN.02.02”
],
MEMORY: [
“IGCSE.PKT.Y.RC.01.01”,
“IGCSE.PKT.Y.RC.02.02”
]
}
---## 15. Packet Routing Engine
text id=”51016″
ROUTER.ENGINE = {
if_new_student:
assign(“IGCSE.PKT.E.MIX.00.01”),
if_ER01_or_ER02_or_ER03_dominant:
assign(“IGCSE.PKT.R.NUM.01.01”),
if_ER04_or_ER05_dominant:
assign(“IGCSE.PKT.R.ALG.01.01”),
if_ER06_dominant:
assign(“IGCSE.PKT.R.ALG.01.02”),
if_ER07_or_ER08_dominant:
assign(“IGCSE.PKT.R.GRF.01.01”),
if_ER09_or_ER10_dominant:
assign(“IGCSE.PKT.R.GEO.01.01”),
if_ER11_or_ER12_dominant:
assign(“IGCSE.PKT.R.MTR.01.01”),
if_ER13_dominant_and_chapter_scores_gt_mixed_scores:
assign(“IGCSE.PKT.T.MIX.01.01”),
if_ER15_dominant:
assign(“IGCSE.PKT.M.PR.01.01”),
if_ER16_dominant:
assign(“IGCSE.PKT.P.CC.01.01”),
if_ER17_or_ER18_dominant:
assign(“IGCSE.PKT.X.EN.01.01”)
}
---## 16. Board-Specific Packet Adjustments
text id=”51017″
BOARD.ADJUSTMENTS = {
Cambridge_0580_or_0980: {
packet_priority_adjustments: [
“Elevate non-calculator packet urgency”,
“Read calculator and non-calculator as separate states”,
“Treat paper-mode instability as structural”
]
},
Pearson_4MA1: {
packet_priority_adjustments: [
“Elevate calculator discipline packet”,
“Elevate mark-capture and final-form packet”,
“Use tier-review logic around Foundation/Higher pressure”
]
}
}
---## 17. Lesson Runtime Layer
text id=”51018″
LESSON.RUNTIME = {
block_00_entry_recall: “2 to 5 minutes”,
block_01_state_read: “What is still broken today?”,
block_02_micro_teach: “Teach the active break only”,
block_03_guided_run: “Tutor-supported execution”,
block_04_solo_run: “Student independent execution”,
block_05_exam_embed: “Convert to exam-style wording”,
block_06_review: “Error-code log”,
block_07_assignment: “Homework tied to packet”
}
LESSON.END_RULE = “Every lesson must end with a next action.”
---## 18. Lesson Decision Logic
text id=”51019″
LESSON.DECISION.LOGIC = {
if_same_error_reopens_immediately:
“hold packet and narrow repair”,
if_error_drops_but_not_stable:
“continue packet under mild variation”,
if_packet_stable:
“add transfer or paper-mode challenge”,
if_new_deeper_weakness_appears:
“reclassify and reorder packets”,
if_mock_cycle_near:
“shift into conditioning mode”
}
---## 19. Homework Runtime Layer
text id=”51020″
HOMEWORK.RUNTIME = {
principle: “Homework continues the active packet”,
repair_state: {
repair: “60%”,
recall: “20%”,
mixed_transfer: “10%”,
presentation: “10%”
},
transfer_state: {
repair: “20%”,
recall: “20%”,
mixed_transfer: “40%”,
paper_mode: “20%”
},
paper_mode_state: {
paper_mode: “50%”,
repair: “20%”,
presentation: “15%”,
review: “15%”
}
}
---## 20. Review Cycle Layer
text id=”51021″
REVIEW.CYCLES = {
micro_review: “Every lesson”,
packet_review: “Every 2 weeks”,
route_review: “Every 4 weeks”,
mock_review: “After every mock”,
tier_review: “When route-fit evidence demands it”
}
---## 21. Packet Review Engine
text id=”51022″
PACKET.REVIEW = {
ask: [
“Did the packet reduce the target error?”,
“Did the same error reopen in mixed work?”,
“Did a new older weakness appear?”,
“Is the student ready for transfer?”
],
decisions: {
promote: “Two clean performances in a row”,
hold: “Progress visible but error still reopens”,
retreat: “Increased demand exposed unresolved floor weakness”,
replace: “Packet was misassigned”
}
}
---## 22. Route Review Engine
text id=”51023″
ROUTE.REVIEW = {
review_dimensions: [
“engine stability”,
“paper-mode risk”,
“mixed-question survival”,
“endurance trend”,
“confidence pattern”,
“tier viability”
],
outputs: [
“continue route”,
“tighten route”,
“slow route”,
“prepare mock cycle”,
“open tier review”
]
}
---## 23. Mock Cycle Layer
text id=”51024″
MOCK.CYCLE = {
pre_mock: [
“reduce novelty”,
“rehearse active packet targets”,
“rehearse time checkpoints”,
“rehearse recovery after one error”
],
during_mock_message: [
“Protect the next mark”,
“Keep method visible”,
“Do not let one break poison the whole paper”
],
post_mock: [
“Use mock postmortem form”,
“Code all loss buckets”,
“Find most expensive repeated error”,
“Change routing”
]
}
---## 24. Loss Bucket Model
text id=”51025″
LOSS.BUCKETS = {
LB1: “Did not know”,
LB2: “Knew but forgot”,
LB3: “Wrong method”,
LB4: “Method right, execution wrong”,
LB5: “Final-form or presentation loss”,
LB6: “Time loss”,
LB7: “Panic loss”
}
---## 25. Tier Review Layer
text id=”51026″
TIER.REVIEW = {
trigger_conditions: [
“current tier appears to cap student”,
“current tier repeatedly traumatises student”,
“mock evidence shows route misfit”,
“routine work and full paper behaviour diverge strongly”
],
Cambridge_questions: [
“Can the student survive both non-calculator and calculator states?”,
“Is Extended a growth route or trauma route?”,
“Is Core protecting the student or capping the student?”
],
Pearson_questions: [
“Is Foundation now below ceiling?”,
“Is Higher supported by stable multi-step control?”,
“Is current comfort true readiness or safe paper comfort?”
],
outputs: [
“hold tier”,
“probe higher route carefully”,
“retreat tier for safety”,
“delay decision and gather more evidence”
]
}
---## 26. Parent Communication Layer
text id=”51027″
PARENT.COMMS = {
frequency: [
“after intake”,
“after first 2 weeks”,
“after mock”,
“after route or tier review”
],
must_include: [
“strengths”,
“main repeated bottleneck”,
“active packets”,
“why this route is chosen”,
“what the next short cycle looks like”
],
avoid: [
“prestige-only language”,
“code-heavy explanation without translation”,
“empty reassurance without mechanism”
]
}
---## 27. Control Tower Layer
text id=”51028″
CONTROL.TOWER = {
INPUTS: [
“diagnostic forms”,
“lesson logs”,
“homework evidence”,
“mock postmortems”,
“parent communication notes”
],
READS: [
“board-fit”,
“tier-fit”,
“dominant engine”,
“dominant error”,
“paper-mode risk”,
“fatigue trend”,
“packet success or failure”
],
DECISIONS: [
“assign packet”,
“hold packet”,
“promote packet”,
“retreat packet”,
“open mock cycle”,
“open tier review”
],
OUTPUTS: [
“current route”,
“next lesson goal”,
“next review date”,
“parent-facing summary”
]
}
---## 28. Minimal Control Panel
text id=”51029″
CONTROL.PANEL.MIN = {
student_id: “”,
board: “”,
tier: “”,
profile_type: “”,
dominant_packet_1: “”,
dominant_packet_2: “”,
dominant_packet_3: “”,
highest_cost_error: “”,
dominant_engine: “”,
paper_mode_risk: “”,
fatigue_risk: “”,
mark_capture_risk: “”,
next_review_date: “”,
next_action: “”
}
---## 29. KPI Layer
text id=”51030″
KPI.LAYER = {
K1: “Dominant error frequency falling”,
K2: “Visible working improving”,
K3: “Mixed-question survival improving”,
K4: “Paper-mode risk falling”,
K5: “Late-paper collapse shrinking”,
K6: “Student self-correction increasing”,
K7: “Packet reviews becoming cleaner”,
K8: “Tier fit becoming clearer”
}
---## 30. Tutor Daily Checklist
text id=”51031″
CHECKLIST.DAILY = [
“Did I identify the dominant error today?”,
“Did the lesson match the active packet?”,
“Did I make the student show reasoning visibly?”,
“Did I measure response, not just deliver explanation?”,
“Did homework continue the packet?”,
“Did I log what improved and what reopened?”,
“Do I know the next lesson goal?”
]
---## 31. Tutor Weekly Checklist
text id=”51032″
CHECKLIST.WEEKLY = [
“Is the most expensive error actually going down?”,
“Is the student stabilising or just coping?”,
“Is paper-mode risk being handled properly?”,
“Is the current route still correct?”,
“Do parents understand the current route?”,
“Does next week have one clear operational goal?”
]
---## 32. Red Flags
text id=”51033″
RED.FLAGS = {
RF1: “Student collapses after one mistake”,
RF2: “Tutor keeps changing packets without evidence”,
RF3: “Student looks strong in chapters but crashes in mixed work”,
RF4: “Cambridge student is calculator-dependent”,
RF5: “Parent pressure is pushing tier ambition beyond readiness”,
RF6: “Mock is discussed as score only”,
RF7: “Homework has become random and packet-free”
}
---## 33. Stop Rules
text id=”51034″
STOP.RULES = {
S1: “Stop introducing new content while the same structural error is still active”,
S2: “Stop praising speed when speed is causing leakage”,
S3: “Stop using marks alone as proof of route fit”,
S4: “Stop assigning transfer packs before floor stability”,
S5: “Stop calling it attitude before testing mechanism”,
S6: “Stop repeating the same worksheet if it is not reducing the target error”
}
---## 34. Escalation Rules
text id=”51035″
ESCALATION.RULES = {
E1: “Escalate to route review if 2-week packet review shows no meaningful reduction”,
E2: “Escalate to tier review if repeated mocks show structural misfit”,
E3: “Escalate parent communication if home pressure is distorting stability”,
E4: “Escalate paper-mode training if Cambridge student freezes in non-calculator work”,
E5: “Escalate endurance conditioning if late-paper decay is repeatedly expensive”
}
---## 35. One-Lesson Decision Tree
text id=”51036″
DECISION.TREE.ONE_LESSON = {
if_new_student:
“Run intake and rapid screen”,
else_if_active_packet_not_working:
“Recheck root cause”,
else_if_packet_working_but_fragile:
“Repeat under mild variation”,
else_if_packet_stable:
“Add transfer or paper-mode challenge”,
else_if_mock_cycle_near:
“Shift into mock conditioning”,
else:
“Continue route and log evidence”
}
---## 36. One-Month Decision Tree
text id=”51037″
DECISION.TREE.ONE_MONTH = {
if_floor_repair_successful:
“Add transfer”,
if_transfer_successful:
“Add timing and paper conditioning”,
if_timing_stable:
“Run mock”,
if_mock_exposes_same_old_error:
“Return to correct repair engine”,
if_mock_shows_route_misfit:
“Open tier review”
}
---## 37. Master Data Schema
text id=”51038″
MASTER.DATA.SCHEMA = {
identity: {},
board_binding: {},
tier_binding: {},
intake_form: {},
rapid_screen: {},
engine_heatmap: {},
error_codes: [],
paper_mode_risk: {},
student_profile: {},
active_packets: [],
lesson_logs: [],
homework_prescriptions: [],
mock_postmortems: [],
route_reviews: [],
tier_reviews: [],
parent_summaries: []
}
---## 38. Runtime Integrity Conditions
text id=”51039″
INTEGRITY.CONDITIONS = {
IC1: “Board must be known”,
IC2: “Tier must be known or explicitly provisional”,
IC3: “Dominant repeated error must be named”,
IC4: “At least one packet must map to that error”,
IC5: “Every lesson must generate a next action”,
IC6: “Every 2 weeks must generate a packet decision”,
IC7: “Every mock must generate a route decision”,
IC8: “Tier shifts must be evidence-led”
}
---## 39. Master Operational Reading
text id=”51040″
MASTER.READING = {
statement_1: “The official board layer defines the exam reality.”,
statement_2: “The eduKateSG layer defines the tutorial control reality.”,
statement_3: “A weak tutorial system explains topics; a strong tutorial system routes students.”,
statement_4: “The goal is not to fill forms. The goal is to reduce repeated loss mechanisms.”,
statement_5: “The final test of the runtime is whether it changes tutor decisions and student stability.”
}
---## 40. Canonical Lock
text id=”51041″
CANONICAL_LOCK = {
CL1: “v9.0 is the fused master runtime stack.”,
CL2: “Board anchor, packet system, forms, runbook, control panel, and decision trees are now one integrated specification.”,
CL3: “The tutorial runtime should now be readable from intake to mock to tier review without changing grammar.”,
CL4: “This stack is designed to be tutor-usable, parent-translatable, and AI-ingestible.”,
CL5: “The runtime succeeds only when it improves routing discipline and reduces execution leakage.”
}
“`
