"
lessons: [
{
id: "slug", // unique within the track
title: "Lesson title",
kind: "lecture", // optional: "lecture" (default), "reading", "exercise", "case"
minutes: 8,
html: "Lesson body as an HTML string.
",
tools: [ // optional: copyable text blocks shown under the lesson
{ label: "Template name", text: "plain text to copy" }
]
}
],
quiz: { // the Week N Examination, 8 to 10 questions, passes at 80%
questions: [
{ q: "Question?", options: ["a", "b", "c", "d"], answer: 0, explain: "Why a is correct." }
]
},
drills: [] // optional, see below
}
// ...more weekly tracks
],
capstone: { // optional: a project brief shown after Week 4
title: "Capstone project title",
html: "The project brief as an HTML string.
"
},
finalExam: { // optional: 12 to 15 questions, passes at 80%
questions: [
{ q: "Question?", options: ["a", "b", "c", "d"], answer: 0, explain: "Why a is correct." }
]
}
});
```
### Completion rules
A program is complete when all of the following hold:
- every lesson has been visited,
- every weekly examination is passed at eighty percent or better,
- every drill (where a track defines them) is done,
- the capstone (if the program defines one) is attested, and
- the final examination (if the program defines one) is passed at eighty percent or better.
Progress lives in `localStorage` under `qmi_academy_v1`, namespaced per program, and includes lesson visits, examination scores, drill scores, the final examination score, and the capstone attestation. Records that predate any of these fields are healed on load rather than crashing.
Then add a `` tag to `index.html`, `learn.html`, and `diploma.html` (alongside the existing content scripts), and make sure `schools.js` lists the school with a matching `id` and `order`.
### Split content files
Because an eight week program is large, its curriculum can be delivered across up to three files per school:
```
content/.js base file: the full program object (weeks 1 to a few)
content/-2.js extension: the next block of weeks
content/-3.js extension: the final block of weeks
```
The base file pushes a full program object as shown above. Each extension file pushes a lighter object that only carries more weekly tracks:
```js
window.QMI_REGISTER = window.QMI_REGISTER || [];
window.QMI_REGISTER.push({
id: "ai-foundations", // the SAME id as the base program
extend: true, // marks this as an extension, not a new program
tracks: [ /* more weekly tracks, same track schema as above */ ]
});
```
`window.QMIAcademy.registry()` merges the registry before the hub, engine, and diploma read it: for every `extend: true` entry, its tracks are appended to the base program with the same `id`. Order is preserved by the script tag order in the HTML (base first, then `-2`, then `-3`), so the weeks stay in sequence. The merge is idempotent, and an extension whose base is not present is ignored.
The HTML loads all three files for every school, after the base file. A missing extension file (a `404`) degrades gracefully: the program simply shows the weeks that did load, and the pacing copy adapts to the actual count. Only the base file is required for a program to appear.
### Drills
`drills` is an optional array of drill objects. Each drill has a unique `id`, a `type` that selects the engine, a `title`, and an `intro`. Three engines exist:
- `type: "spot"` reads `techniques: [string]` and `items: [{ text, answer, why }]` where `answer` is one of the techniques.
- `type: "inbox"` reads `emails: [{ from, subject, preview, suspicious, why }]`.
- `type: "calibration"` reads `items: [{ claim, isTrue, why }]`.
See `content/cognitive-security.js` for complete, working examples of all three.
### Lesson checkpoints and widgets
Any lesson may carry two optional fields that the engine renders after the lesson body: `checks` (inline checkpoint questions) and `widgets` (interactive practice cards). Both are optional; a lesson without them renders exactly as before. Old saved progress keeps working, since these only add new keys.
#### `lesson.checks`
One to three inline checkpoint questions, rendered as a styled "Checkpoint" block after the lesson body. Each question locks on the first answer, shows the correct option and an explanation, and persists per lesson. Checkpoints never gate progress; they are a self check. Answering a checkpoint correctly on the first try earns a small point bonus.
```js
checks: [
{
q: "Question text?",
options: ["a", "b", "c", "d"], // exactly four strings
answer: 1, // index of the correct option
explain: "Why that answer is correct."
}
// up to three
]
```
#### `lesson.widgets`
Zero or more interactive cards, rendered after the checkpoints, one card each, in order. Unknown types are skipped gracefully. The five shapes are exact:
```js
widgets: [
// 1. reveal: a prompt, then a button flips to the answer.
{ type: "reveal", prompt: "", answer: "" },
// 2. match: two columns, click one on each side to pair. 4 to 8 pairs.
{ type: "match", instruction: "...", pairs: [ ["left", "right"], /* ... */ ] },
// 3. sort: items given in CORRECT order; the engine shuffles them
// (deterministically, seeded from the lesson id, never starting solved).
{ type: "sort", instruction: "...", items: [ "first", "second", /* ... */ ] },
// 4. scenario: a setup, then options; exactly one has best: true.
{ type: "scenario", setup: "", options: [
{ text: "...", feedback: "...", best: true },
{ text: "...", feedback: "...", best: false }
] },
// 5. flashcards: a click to flip deck, prev and next. 5 to 12 cards.
{ type: "flashcards", title: "...", cards: [ { front: "...", back: "..." } /* ... */ ] }
]
```
Notes for contributors:
- `reveal.prompt`, `reveal.answer`, and `scenario.setup` accept HTML strings (like `lesson.html`). Everything else (`match` pairs, `sort` items, `scenario` option text and feedback, flashcard `front` and `back`) is plain text and is escaped by the engine.
- `sort` items must be listed in their correct final order. The learner sees them shuffled and reorders with arrows or drag; the shuffle is stable per lesson and re-solvable.
- `scenario` must have exactly one option with `best: true`.
- All widgets are keyboard accessible and mobile friendly, and use transitions only, no continuous animation.
### Light mastery: points and streak
The engine keeps a modest, honest mastery layer, stored in the same `qmi_academy_v1` key. Points are **recomputed from real progress on every read**, never banked, so they cannot drift or be gamed: a lesson visit earns points, a checkpoint answered correctly on the first try earns a bonus, a passed weekly examination earns more, and the capstone, final, and whole program each add a lump. A small points chip and a gentle day streak show in the course sidebar, and per program point totals show on the hub cards. Points are a personal study aid, not a score of competence, and the interface says so. Passing an examination and completing a program each trigger a brief, CSS only flourish.
## Writing guidelines for contributors
- Defensive and honest framing. Teach recognition and understanding, never how to cause harm.
- Keep lessons substantive and concrete, roughly 300 to 600 words, with real examples.
- Do not use em dashes or en dashes anywhere. Use commas, colons, or periods instead.
- Keep the tone clear, honest, and calm. Avoid hype and fear mongering.
- Do not overclaim. Certificates record completion, not competence.
## License
MIT, copyright 2026 QuantixMind Institute. See [LICENSE](LICENSE).