Tutor Runbook
Step-by-Step Operator Manual in Full Almost Code
This runbook sits on top of the existing board-bound layer.
Use Cambridge 0580, Cambridge 0980, or Pearson 4MA1 as the qualification object first, then run the tutorial system through the steps below.
This is the eduKateSG operator manual.
It is not official board wording.
Its purpose is to tell the tutor exactly what to do next, from intake to lesson flow to packet review to tier review.
0. Meta Lock
“`text id=”41001″
DOC.NAME = “IGCSE Mathematics Tutorial by eduKateSG v8.0”
DOC.TYPE = “Tutor Runbook”
DOC.MODE = “Step-by-Step Operator Manual”
DOC.DEFAULT_BINDING = “Cambridge 0580”
DOC.COMPATIBILITY = [“Cambridge 0980”, “Pearson 4MA1”]
DOC.PURPOSE = “Tell the tutor what to do from first contact to review cycle”
DOC.BOUNDARY = “Board and tier must be identified before packet routing begins”
DOC.PRIMARY_OBJECT = “Operational clarity”
---## 1. Core Thesis
text id=”41002″
RUNBOOK.THESIS = “Do not teach randomly. Read the student, classify the failure, assign the right packet, run the lesson, measure the response, and update the route.”
RUNBOOK.CORE_RULES = {
R1: “Board first”,
R2: “Tier first”,
R3: “Floor before speed”,
R4: “Repair before transfer”,
R5: “Transfer before confidence claims”,
R6: “Mock results must change routing”,
R7: “Review cycles are mandatory”
}
---## 2. Full Operator Sequence
text id=”41003″
OPERATOR.SEQUENCE = [
“Stage 0: Confirm board and tier”,
“Stage 1: Intake and rapid screen”,
“Stage 2: Diagnostic classification”,
“Stage 3: Packet assignment”,
“Stage 4: Lesson 1 intervention”,
“Stage 5: Homework prescription”,
“Stage 6: Lesson-by-lesson state reading”,
“Stage 7: 2-week packet review”,
“Stage 8: 4-week route review”,
“Stage 9: Mock conditioning and postmortem”,
“Stage 10: Tier review when needed”
]
---## 3. Stage 0## Board and Tier Binding
text id=”41004″
STAGE_0.BOARD_BINDING = {
Step_0_1: “Identify board”,
Step_0_2: “Identify qualification code”,
Step_0_3: “Identify tier”,
Step_0_4: “Identify calculator structure”,
Step_0_5: “Record target grade and likely route pressure”
}
STAGE_0.BOARD_OPTIONS = {
Cambridge_0580: {
tiers: [“Core”, “Extended”],
paper_modes: [“Non-Calculator”, “Calculator”]
},
Cambridge_0980: {
tiers: [“Core”, “Extended”],
paper_modes: [“Non-Calculator”, “Calculator”]
},
Pearson_4MA1: {
tiers: [“Foundation”, “Higher”],
paper_modes: [“Calculator-led written papers”]
}
}
STAGE_0.FAIL_RULE = “If board is unknown, do not pretend packet assignment is precise yet.”
---## 4. Stage 1## Intake Workflow
text id=”41005″
STAGE_1.INTAKE = {
use_form: “FORM.D01.MASTER_INTAKE”,
collect: [
“recent scores”,
“student concerns”,
“parent concerns”,
“prior tuition history”,
“calculator dependence”,
“confidence and stamina signals”
],
observe: [
“working visibility”,
“hesitation points”,
“panic signs”,
“speed-quality tradeoff”
],
output: [
“route_hypothesis”,
“likely_profile_type”,
“dominant_error_guess”,
“initial_packets_to_test”
]
}
STAGE_1.SUCCESS = “Tutor can state what the student most likely is, not just what the student complains about.”
---## 5. Stage 2## Rapid Screen Workflow
text id=”41006″
STAGE_2.RAPID_SCREEN = {
use_form: “FORM.D02.RAPID_SCREEN”,
run_tasks: {
number: “short arithmetic and fractions probe”,
algebra: “signs, expansion, rearrangement probe”,
graphs: “read gradient/intercept or visual relation”,
geometry: “angle/property mini item”,
measure_trig: “formula or trig-choice mini item”,
data: “read-and-infer mini item”
},
observe: [
“which engine breaks first”,
“which error repeats”,
“whether the student freezes or fights through”
],
output: [
“strongest area”,
“weakest area”,
“dominant_error_guess”,
“paper_mode_risk_guess”
]
}
---## 6. Stage 3## Diagnostic Classification
text id=”41007″
STAGE_3.CLASSIFICATION = {
use_forms: [
“FORM.D03.ENGINE_HEATMAP”,
“FORM.D04.ERROR_CODING”,
“FORM.D05.PAPER_MODE_RISK”,
“FORM.D08.STUDENT_PROFILE”
],
classify_into: [
“SP1_Fragile_Foundation”,
“SP2_Symbol_Drifter”,
“SP3_Visual_Collapser”,
“SP4_False_Safe”,
“SP5_Calculator_Dependent”,
“SP6_Time_Collapser”,
“SP7_Mark_Leaker”,
“SP8_Anxious_Knower”
],
identify: {
dominant_engine: “”,
dominant_error_codes: [],
most_expensive_repeated_error: “”,
paper_mode_risk: “”,
confidence_pattern: “”
}
}
STAGE_3.SUCCESS = “Tutor can explain the failure mechanism in one sentence.”
Example output sentence:
text id=”41008″
CLASSIFICATION.ONE_LINE =
“Student is a False Safe Extended student with sign drift, weak trig-family selection, and compressed working.”
---## 7. Stage 4## Packet Assignment Workflow
text id=”41009″
STAGE_4.PACKET_ASSIGNMENT = {
use_forms: [
“FORM.D09.PACKET_MATRIX”,
“FORM.D14.PACKET_ASSIGNMENT”
],
packet_limit: “3 active packets maximum”,
exception: “pre-exam conditioning may temporarily exceed 3”,
choose: [
“1 primary packet”,
“1 secondary packet”,
“1 optional support packet”
],
ordering_rule: [
“foundation repair first”,
“paper-mode repair second if urgent”,
“transfer pack only after floor is usable”,
“mark-capture pack when hidden working is expensive”
]
}
STAGE_4.FAIL_RULE = “Do not assign advanced transfer packs to a student whose floor is still collapsing.”
---## 8. Stage 5## Lesson 1 Runbook
text id=”41010″
LESSON_1.RUNBOOK = {
goal: “Confirm the diagnosis and begin the first true intervention”,
sequence: [
"Block 1: 2-minute recall warm-up","Block 2: Reproduce one known failure slowly","Block 3: Show correct method visibly","Block 4: Make student narrate each step","Block 5: Repeat with reduced tutor support","Block 6: Convert same skill into exam-style wording","Block 7: Log dominant error and homework assignment"
],
tutor_must_check: [
“Did the student actually understand the correction?”,
“Did the same error reopen immediately?”,
“Did visible working improve?”
],
output: [
“first_response_to_packet”,
“homework_prescription”,
“whether the packet seems correctly chosen”
]
}
Tutor language example:
text id=”41011″
SCRIPT.LESSON_1 = [
“Show me where this started to go wrong.”,
“Do this line again, but say what you are doing.”,
“Good. Now do the next line without me.”,
“Now do it in exam form, not comfort form.”
]
---## 9. Stage 6## Lesson 2 Runbook
text id=”41012″
LESSON_2.RUNBOOK = {
goal: “Check whether the packet is reducing the intended error”,
sequence: [
"Block 1: Retrieval strip from previous lesson","Block 2: Re-test original failure family","Block 3: Add slight variation","Block 4: Add mild time pressure","Block 5: Log whether the same error reopens","Block 6: Assign same packet or escalate carefully"
],
decision_points: {
if_error_frequency_drops: “continue packet”,
if_error_changes_form_but_same_root: “continue and narrow”,
if_packet_has_no_effect: “reclassify after evidence check”
}
}
---## 10. Standard Lesson Runtime## Every Normal Lesson After Setup
text id=”41013″
LESSON.RUNTIME.STANDARD = {
block_00_entry_recall: “2 to 5 minutes”,
block_01_state_read: “What is still broken today?”,
block_02_packet_repair: “Main intervention block”,
block_03_guided_run: “Tutor-supported execution”,
block_04_solo_run: “Student independent execution”,
block_05_exam_embed: “Convert to exam-style question”,
block_06_review: “Error code logging”,
block_07_assignment: “Homework tied to packet”
}
LESSON.RUNTIME.RULE = “Every lesson must end with a next action.”
---## 11. Week 1 Runbook
text id=”41014″
WEEK_1.RUNBOOK = {
objective: “Stabilise diagnosis and repair dominant failure”,
tutor_focus: [
“confirm packet fit”,
“reduce most expensive repeated error”,
“build visible working if weak”
],
do: [
“run intake if not done”,
“assign initial packets”,
“avoid overloading with mixed papers too early”
],
do_not: [
“accelerate because the student seems bright”,
“switch packets every lesson without evidence”
],
success_marker: “Tutor can see one error family reducing in live work”
}
---## 12. Week 2 Runbook
text id=”41015″
WEEK_2.RUNBOOK = {
objective: “Strengthen repair and test light transfer”,
tutor_focus: [
“same error under slight variation”,
“same error under mild timing”,
“same error in a nearby context”
],
add_if_ready: [
“light transfer strip”,
“memory/recall strip”,
“mark-capture support”
],
hold_if: [
“same old floor break still frequent”,
“confidence collapses under small pressure”
],
success_marker: “Student starts surviving variation rather than only repeating the same item”
}
---## 13. Week 3 Runbook
text id=”41016″
WEEK_3.RUNBOOK = {
objective: “Move from repair into controlled transfer”,
tutor_focus: [
“mixed-question survival”,
“multi-step persistence”,
“topic-family identification”
],
activate_possible_packets: [
“IGCSE.PKT.T.MIX.01.01”,
“IGCSE.PKT.T.MIX.02.02”
],
ask: [
“What topic families are inside this question?”,
“What is the safest first step?”,
“Where does algebra become geometry or data?”
],
success_marker: “Student no longer says ‘I don’t know this’ when it is actually mixed known content”
}
---## 14. Week 4 Runbook
text id=”41017″
WEEK_4.RUNBOOK = {
objective: “Review route, not just lesson success”,
tutor_focus: [
“2-week packet review”,
“4-week route review”,
“mock-readiness or tier-readiness decision”
],
use_forms: [
“FORM.D17.REVIEW_MEETING”,
“FORM.D13.ONEPAGE_OUTPUT”,
“FORM.D11.ROUTE_PLANNER_4WEEK”
],
decide: [
“promote packet”,
“hold packet”,
“retreat and repair again”,
“add paper conditioning”,
“consider tier review if needed”
]
}
---## 15. Homework Runbook
text id=”41018″
HOMEWORK.RUNBOOK = {
principle: “Homework continues the packet. It does not replace the packet.”,
prescribe_by_state: {
repair_state: { ratio: { repair: "60%", recall: "20%", mixed_transfer: "10%", presentation: "10%" }},transfer_state: { ratio: { repair: "20%", recall: "20%", mixed_transfer: "40%", paper_mode: "20%" }},paper_mode_state: { ratio: { paper_mode: "50%", repair: "20%", presentation: "15%", review: "15%" }}
},
tutor_must_specify: [
“what to do”,
“how much to do”,
“what quality standard is expected”,
“what error to watch for”
]
}
---## 16. Packet Review Runbook## Every 2 Weeks
text id=”41019″
PACKET_REVIEW.RUNBOOK = {
cycle: “Every 2 weeks”,
ask: [
“Did the packet reduce the target error?”,
“Did the same error reopen in mixed context?”,
“Did a new more basic weakness appear?”,
“Is the student now ready for transfer?”
],
decisions: {
promote: “If two clean performances appear in a row”,
hold: “If progress exists but the target error still reopens”,
retreat: “If increased demand exposed unresolved floor weakness”,
replace: “If packet was incorrectly chosen”
},
output: [
“keep packet”,
“switch packet”,
“add support packet”,
“remove redundant packet”
]
}
---## 17. Route Review Runbook## Every 4 Weeks
text id=”41020″
ROUTE_REVIEW.RUNBOOK = {
cycle: “Every 4 weeks”,
review_dimensions: [
“engine stability”,
“paper-mode risk”,
“mixed-question survival”,
“endurance trend”,
“confidence pattern”,
“tier viability”
],
use_forms: [
“FORM.D11.ROUTE_PLANNER_4WEEK”,
“FORM.D17.REVIEW_MEETING”,
“FORM.D12.PARENT_SUMMARY”
],
output: [
“continue route”,
“tighten route”,
“slow route”,
“prepare mock cycle”,
“open tier review discussion”
]
}
---## 18. Mock Week Runbook
text id=”41021″
MOCK_WEEK.RUNBOOK = {
pre_mock: [
“reduce novelty”,
“review active packet targets only”,
“rehearse time checkpoints”,
“rehearse calm-recovery after mistakes”
],
during_mock_coaching_message: [
“Keep method visible”,
“Do not panic after one break”,
“Protect the next mark, not the lost mark”
],
post_mock: [
“use FORM.D07.MOCK_POSTMORTEM”,
“code every loss bucket”,
“identify most expensive repeated error”,
“change packets based on evidence”
]
}
MOCK_WEEK.FAIL_RULE = “A mock is wasted if the tutor only discusses score and not mechanism.”
---## 19. Tier Review Week Runbook
text id=”41022″
TIER_REVIEW.RUNBOOK = {
trigger_conditions: [
“student is repeatedly capped by current tier”,
“student is repeatedly traumatised by current tier”,
“mock evidence shows route misfit”,
“routine scores and real paper behaviour diverge strongly”
],
use_form: “FORM.D06.TIER_REVIEW”,
ask_by_board: {
Cambridge: [ "Can the student survive both non-calculator and calculator demands?", "Is Extended a growth route or trauma route?", "Is Core protecting the student or capping the student?"],Pearson: [ "Is Foundation now below ceiling?", "Is Higher supported by stable algebra and multi-step control?", "Is current performance driven by real structure or safe paper comfort?"]
},
output: [
“hold tier”,
“probe higher route carefully”,
“retreat tier for safety”,
“delay decision and gather more evidence”
]
}
---## 20. Board-Specific Tutor Adjustments
text id=”41023″
BOARD_ADJUSTMENTS = {
Cambridge_0580_or_0980: {
emphasis: [
“separate non-calculator conditioning”,
“calculator versus non-calculator state reading”,
“visible method under both paper modes”
]
},
Pearson_4MA1: {
emphasis: [
“calculator discipline”,
“presentation and final-form control”,
“higher versus foundation route pressure”
]
}
}
---## 21. Red-Flag Conditions## Immediate Tutor Response Required
text id=”41024″
RED_FLAGS = {
RF1: “Student confidence collapses after one error”,
RF2: “Tutor changes packets too often without evidence”,
RF3: “Student appears strong in chapters but crashes in mixed work”,
RF4: “Cambridge student shows strong calculator dependence”,
RF5: “Parent pressure is pushing tier ambition beyond structural readiness”,
RF6: “Mock score is being discussed without loss-bucket analysis”,
RF7: “Homework is random and no longer tied to the packet”
}
RED_FLAG.RESPONSE = {
Step_1: “Pause acceleration”,
Step_2: “Return to error evidence”,
Step_3: “Recheck floor”,
Step_4: “Adjust packet order”,
Step_5: “Communicate clearly with parent/student”
}
---## 22. Tutor Stop Rules
text id=”41025″
STOP_RULES = {
S1: “Stop introducing new content if the same structural error is still active.”,
S2: “Stop praising speed if speed is driving error leakage.”,
S3: “Stop using marks alone as proof of route fit.”,
S4: “Stop assigning mixed packs if floor repair is still incomplete.”,
S5: “Stop blaming attitude before testing mechanism.”,
S6: “Stop repeating the same worksheet if it is not reducing the target error.”
}
---## 23. Tutor Escalation Rules
text id=”41026″
ESCALATION_RULES = {
E1: “Escalate to route review if 2-week packet review shows no meaningful reduction in dominant error.”,
E2: “Escalate to tier review if repeated mock evidence shows structural misfit.”,
E3: “Escalate parent communication if home pressure is distorting route stability.”,
E4: “Escalate paper-mode training if Cambridge student freezes in non-calculator conditions.”,
E5: “Escalate endurance conditioning if late-paper decay is repeatedly expensive.”
}
---## 24. Parent Communication Runbook
text id=”41027″
PARENT_COMMUNICATION.RUNBOOK = {
frequency: [
“after intake”,
“after first 2 weeks”,
“after mock”,
“after route or tier review”
],
say: [
“what is strong”,
“what is unstable”,
“what packet is active”,
“why this route is chosen”,
“what the next short cycle looks like”
],
avoid: [
“too much code language”,
“prestige language without evidence”,
“empty reassurance without mechanism”
]
}
Example parent summary structure:
text id=”41028″
PARENT.MESSAGE.STRUCTURE = [
“Your child’s current strengths are…”,
“The main repeated bottleneck is…”,
“So the current packet focus is…”,
“Over the next 2 weeks we are aiming to…”
]
---## 25. Minimal KPI Dashboard
text id=”41029″
KPI.DASHBOARD = {
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 review outcomes becoming cleaner”,
K8: “Tier fit becoming clearer”
}
---## 26. One-Lesson Decision Tree
text id=”41030″
DECISION_TREE.ONE_LESSON = {
if_new_student:
“Run intake + rapid screen”,
else_if_active_packet_not_working:
“Recheck root cause and packet fit”,
else_if_packet_working_but_fragile:
“Repeat packet under mild variation”,
else_if_packet_stable:
“Add transfer or paper-mode challenge”,
else_if_mock_cycle_near:
“Shift into mock conditioning”,
else:
“Continue current route with evidence logging”
}
---## 27. One-Month Decision Tree
text id=”41031″
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 repair at the right engine”,
if_mock_shows_route_misfit:
“Open tier review”
}
---## 28. Canonical Daily Tutor Checklist
text id=”41032″
CHECKLIST.DAILY_TUTOR = [
“Did I identify the active dominant error today?”,
“Did today’s lesson match the active packet?”,
“Did I make the student show visible working?”,
“Did I measure response, not just deliver content?”,
“Did I assign homework that continues the packet?”,
“Did I log what improved and what reopened?”,
“Do I know what the next lesson is for?”
]
---## 29. Canonical Weekly Tutor Checklist
text id=”41033″
CHECKLIST.WEEKLY_TUTOR = [
“Is the same expensive error going down?”,
“Is the student stabilising or merely coping?”,
“Is paper-mode risk being handled properly?”,
“Is the current route still correct?”,
“Do the parents understand what we are doing?”,
“Does the next week have a clear operational goal?”
]
---## 30. Canonical Lock
text id=”41034″
CANONICAL_LOCK = {
CL1: “v8.0 is the tutor’s step-by-step operator manual.”,
CL2: “The tutor should always know what stage the student is currently in.”,
CL3: “Good tutoring is not random explanation; it is controlled routing.”,
CL4: “Every lesson, week, mock, and review must produce a next decision.”,
CL5: “The runbook exists to turn diagnosis into disciplined action.”
}
“`
The clean next continuation is v9.0 Full Tutorial Runtime Specification, where I fuse the packet system, forms, runbook, control panel, and decision trees into one single master technical documentation stack.