@thanh01.pmt/curriculum-kit 1.4.40 → 1.4.42

package/dist/templates/QUIZ_template.md

@@ -0,0 +1,58 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "QUIZ"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "P2-T08"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+---
+<!-- 
+  Created by: Curriculum OS Builder
+  Phase: P2 | Deliverable: P2-T08 (Assessment Infrastructure)
+  Version: v4.6 | Date: 2026-05-06
+  Alignment: interactive-quiz-kit/src/schemas/zod/multipleChoiceQuestionSchema.ts
+-->
+
+# QUIZ TEMPLATE (V4.6 - JSON-READY)
+
+## 1. Metadata Specs
+- **Format**: Strictly valid JSON or YAML block inside Markdown.
+- **Language**: English (Primary Keys), Vietnamese (Content).
+- **Target Audience**: 15-18 Years Old (Pathway AIoT).
+
+## 2. Schema Structure
+FOLLOW THIS JSON STRUCTURE FOR EACH QUESTION:
+
+```json
+{
+  "id": "quiz-[unit]-[lesson]-[sequence]",
+  "questionTypeCode": "MULTIPLE_CHOICE",
+  "prompt": "Your question statement here...",
+  "options": [
+    { "id": "opt-1", "text": "Option A text" },
+    { "id": "opt-2", "text": "Option B text" },
+    { "id": "opt-3", "text": "Option C text" },
+    { "id": "opt-4", "text": "Option D text" }
+  ],
+  "correctAnswerId": "opt-X",
+  "points": 10,
+  "explanation": "Detailed pedagogical explanation grounded in the lesson content.",
+  "bloomLevelCode": "[REMEMBER|UNDERSTAND|APPLY|ANALYZE|EVALUATE|CREATE]",
+  "difficultyCode": "[VERY_EASY|EASY|MEDIUM|HARD|VERY_HARD]",
+  "learningObjective": "[LO_CODE]",
+  "topic": "[TOPIC_NAME]"
+}
+```
+
+## 3. Pedagogical Rules
+- **Distractors**: Options MUST be plausible misconceptions based on lesson theory.
+- **Tone**: Professional, encouraging, and technically precise.
+- **Alignment**: Every question MUST map to at least one LO from the lesson.
+
+## 4. Visual Layout (Marp/Interactive)
+If rendering to slides:
+- Use `glass-card` layout.
+- One question per slide.
+- Highlight correct answer only in "Teacher Mode".

package/dist/templates/QUIZ_v4.6_template.md

@@ -0,0 +1,65 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "QUIZ"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "P2-T08"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+template_contract: "artifact-template-v1"
+template_required_sections:
+  - "Assessment Objectives"
+  - "Multiple-Choice Question Bank"
+  - "Code Analysis / Debugging Question"
+  - "Competency Rubric"
+---
+
+# QUIZ: [LESSON TITLE]
+
+## [REQUIRED] Assessment Objectives
+> One row per Learning Objective from the LESSON A1 table. Bloom level of each
+> objective MUST match the LESSON A1 Bloom verb — do not re-target.
+
+| LO | Assessment Objective | Bloom Level | Evidence Measured |
+|---|---|---|---|
+| LO1 | [What this quiz verifies for LO1] | [Same Bloom verb as LESSON A1] | [Observable student output] |
+
+## [REQUIRED] Multiple-Choice Question Bank
+> ≥5 scenario-based questions, 4 options each. Every distractor must be a real,
+> common misconception from this lesson's domain (see Common Mistakes source in
+> the canonical knowledge context) — never random filler.
+
+### Q1. [Question stem — scenario or direct probe]
+- A. [Option]
+- B. [Option]
+- C. [Option]
+- D. [Option]
+- **Correct:** [Letter]
+- **Bloom:** [REMEMBER|UNDERSTAND|APPLY|ANALYZE|EVALUATE|CREATE]
+- **LO:** [LO code]
+- **Distractor rationale:** [Why each wrong option is plausible — the misconception it targets]
+
+<!-- Repeat per question. -->
+
+## [REQUIRED] Code Analysis / Debugging Question
+> One deep code-tracing task: students predict output or identify the bug.
+> Provide a complete, runnable snippet with line numbers.
+
+```[language]
+// [Complete, runnable snippet]
+```
+
+- **Question:** [What must students predict / find?]
+- **Expected answer:** [Output or bug + fix]
+- **Bloom:** [Level] — **LO:** [LO code]
+
+## [REQUIRED] Competency Rubric
+> 4-tier matrix tied to the Evidence column above.
+
+| Tier | Descriptor | Evidence Threshold |
+|---|---|---|
+| Developing | [Below-minimum performance] | [Observable indicator] |
+| Proficient | [Session target — minimum exit bar] | [Observable indicator] |
+| Advanced | [Beyond target, independent transfer] | [Observable indicator] |
+| Exemplary | [Creative extension / peer-teaching level] | [Observable indicator] |

package/dist/templates/REFERENCE_PACK_template.md

@@ -0,0 +1,26 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "REFERENCE_PACK"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "{{DELIVERABLE_CODE}}"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+---
+
+# REFERENCE PACK: Pedagogical Source Grounds
+
+This document contains validated technical references for curriculum development. All technical facts in the lessons MUST align with these sources.
+
+## 📊 Coverage Summary
+- **Total References**: {{total_refs}}
+- **LO Coverage**: {{covered_count}} / {{target_count}} ({{percentage}}%)
+
+{{summary_table}}
+
+---
+
+## 📚 Detailed Technical References
+
+{{detailed_entries}}

package/dist/templates/REVIEW_GAME_template.md

@@ -0,0 +1,79 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "REVIEW_GAME"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "P3-T17"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+template_contract: "artifact-template-v1"
+template_required_sections:
+  - "Game Rules & Setup Guide"
+  - "Round 1: Speed Round (100-200 Pts)"
+  - "Round 2: Code Duel & Debugging (300-400 Pts)"
+  - "Round 3: Final Boss Architecture Challenge (500 Pts)"
+  - "Kahoot / Quizizz CSV Export Format"
+---
+<!-- INJECT_BODY -->
+
+# INTERACTIVE REVIEW GAME (QUIZ SHOW PACK): [UNIT / LESSON TITLE]
+_Unit: U[X] | Module: M[X.X] | Format: Live Classroom Quiz Show / Kahoot / Jeopardy Format_
+
+## [REQUIRED] Game Rules & Setup Guide
+- **Format:** 3 Rounds of progressive difficulty with team buzzers or interactive clickers.
+- **Team Size:** 3-5 students per squad.
+- **Bonus Mechanic:** Teams can wager points on Round 3 (Final Boss Challenge).
+
+---
+
+## [REQUIRED] Round 1: Rapid-Fire Speed Round (100–200 Points)
+
+### Question 1 (100 Pts):
+- **Category:** Vocabulary & Syntax
+- **Prompt:** "What is the primary difference between `Task` and `Task.detached`?"
+- **Options:**
+  - `[A]` `Task.detached` inherits actor context; `Task` does not.
+  - `[B]` `Task` inherits actor context & priority; `Task.detached` runs completely unisolated. *(Correct)*
+  - `[C]` `Task` cannot throw errors; `Task.detached` can.
+  - `[D]` There is no difference.
+
+### Question 2 (200 Pts):
+- **Category:** Mental Model
+- **Prompt:** "Why are SwiftUI Views declared as `struct` (Value Types) rather than `class` (Reference Types)?"
+- **Answer:** Value types enforce immutability, make state mutation explicit, and allow lightweight view tree instantiation with zero heap fragmentation.
+
+---
+
+## [REQUIRED] Round 2: Code Duel & Debugging (300–400 Points)
+
+### Challenge 1 (300 Pts):
+- **Prompt:** First team to buzz in and explain why this code fails compilation wins 300 pts!
+```swift
+class DataStore {
+    var items: [String] = []
+}
+func updateStore(store: DataStore) async {
+    // Calling across concurrency boundary without Sendable conformance
+}
+```
+- **Winning Explanation:** `DataStore` is a non-final reference type with mutable state; it does not conform to `Sendable` and cannot safely cross task boundaries.
+
+---
+
+## [REQUIRED] Round 3: Final Boss Architecture Challenge (500 Points)
+- **Scenario:** "Design a real-time multiplayer scorekeeper using Swift 6 Actors. You have 3 minutes to draft the Actor interface on your team whiteboard."
+- **Rubric:**
+  - `+200 pts:` Declared `actor ScoreKeeper`.
+  - `+150 pts:` Thread-safe async update method.
+  - `+150 pts:` Non-blocking read access with `isolated` parameters where appropriate.
+
+---
+
+## [REQUIRED] Kahoot / Quizizz CSV Export Format
+```csv
+Question,Option 1,Option 2,Option 3,Option 4,Correct Answer,Time Limit (sec)
+"What keyword creates an asynchronous suspension point?","defer","await","return","yield",2,20
+"Which property wrapper creates local view-owned state?","@Binding","@State","@ObservedObject","@Environment",2,20
+"What protocol marks types safe to share across concurrency boundaries?","Codable","Equatable","Sendable","Identifiable",3,30
+```

package/dist/templates/RUBRIC_template.md

@@ -0,0 +1,54 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "RUBRIC"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "{{DELIVERABLE_CODE}}"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+template_contract: "artifact-template-v1"
+template_required_sections:
+  - "Assessment Overview"
+  - "Assessment Rubric"
+---
+
+# ASSESSMENT: [LESSON/PROJECT TITLE]
+
+_Unit: U[X] | Module: M[X.X] | Lesson: Lesson [XX]_
+
+## [REQUIRED] Assessment Overview
+- **Type:** [Select: Formative / Summative / Self-assessment / Peer-review]
+- **Format:** [Select: Short Exercise / Exit Ticket / Practical Product / Project Presentation]
+- **Learning Objectives Measured:** [Copy 1-2 LOs from the corresponding Lesson Plan]
+- **Target Language:** [Select: For Teachers (Technical/Pedagogical) / For Students (Simple/Friendly "I can..." language)]
+
+---
+
+## [REQUIRED] Assessment Rubric
+_Note for @assessor: Describe SPECIFIC behaviors. Avoid vague words like "good" or "understand."_
+
+| Criteria | Weight | Excellent (4) | Proficient (3) | Developing (2) | Beginning (1) |
+|---|:---:|---|---|---|---|
+| **[Criteria 1]**<br>_(e.g., Circuitry)_ | [X]% | [e.g., 100% correct connection, neat wiring, follows color conventions.] | [e.g., Circuit works correctly, but wiring is disorganized.] | [e.g., Circuit partially works, requires teacher input to fix errors.] | [e.g., Incorrect wiring makes the circuit non-functional, unable to debug.] |
+| **[Criteria 2]**<br>_(e.g., Coding)_ | [Y]% | [Level 4 description] | [Level 3 description] | [Level 2 description] | [Level 1 description] |
+| **[Criteria 3]**<br>_(e.g., Teamwork)_ | [Z]% | [Level 4 description] | [Level 3 description] | [Level 2 description] | [Level 1 description] |
+
+---
+
+## [OPTIONAL] Exit Ticket
+_Used at the end of class for a quick pulse check (Max 3 questions)._
+1. **Question 1 (Recall/Recall):** [Multiple choice or True/False]
+   - **Answer:** [Correct answer]
+2. **Question 2 (Apply):** [Short situational question]
+   - **Answer / Scoring Guide:** [Grading instruction]
+3. **Question 3 (Reflection):** What was the most challenging part of today's lesson? (Open-ended)
+
+---
+
+## [OPTIONAL] Student Self-Assessment Checklist
+_Simple language for students to reflect after completing a project._
+- [ ] I have completed the product according to the requirements.
+- [ ] I can explain how the code/circuit works to others.
+- [ ] I fixed at least one bug on my own (or with my group).
+- **One thing I am most proud of in my product is:** ___________________________

package/dist/templates/SCIENCE_LAB_template.md

@@ -0,0 +1,88 @@
+---
+id: "{{ID}}"
+title: "{{TITLE}}"
+type: "SCIENCE_LAB"
+created_by: "Curriculum OS Builder"
+phase: "{{PHASE}}"
+deliverable: "P3-T13"
+version: "{{VERSION}}"
+date: "{{DATE}}"
+template_contract: "artifact-template-v1"
+template_required_sections:
+  - "Guiding Inquiry & Driving Question"
+  - "Hypothesis & Experimental Design"
+  - "Data Collection & Code Lab Protocol"
+  - "CER Scientific Conclusion (Claim, Evidence, Reasoning)"
+  - "Peer Review & Verification Protocol"
+---
+<!-- INJECT_BODY -->
+
+# STEM / CODE INVESTIGATION LAB (CER): [LAB TITLE]
+_Unit: U[X] | Module: M[X.X] | Domain: [Scientific / Engineering Domain]_
+
+## [REQUIRED] Guiding Inquiry & Driving Question
+- **Real-World Driving Question:** [E.g., "How does thread contention affect application frame rate (FPS) and memory throughput under heavy load?"]
+- **Engineering Phenomenon:** [E.g., "When two tasks write to the same mutable array simultaneously, why does the program crash intermittently rather than every single run?"]
+
+---
+
+## [REQUIRED] Hypothesis & Experimental Design
+- **Student Hypothesis Template:**  
+  > *"If we [Action / Variable Manipulation, e.g., 'isolate the shared mutable resource inside an Actor instead of using a global lock'], then [Predicted Outcome, e.g., 'data races will drop to zero and UI thread latency will remain under 16ms'] because [Scientific / Engineering Rationale]."*
+
+### Controlled Variables:
+- **Independent Variable (Manipulated):** [E.g., Number of concurrent tasks: 1, 10, 100, 1000].
+- **Dependent Variable (Measured):** [E.g., Execution time (ms), Data Race crash count, CPU core utilization (%)].
+- **Control Variables (Constant):** [E.g., Device hardware, input data size, operating system version].
+
+---
+
+## [REQUIRED] Data Collection & Code Lab Protocol
+
+### Lab Setup & Instrumentation Code:
+```swift
+// Benchmark / Probe harness provided to students
+import Foundation
+
+struct BenchmarkProbe {
+    static func runExperiment(iterations: Int, concurrencyLevel: Int) async -> ExperimentResult {
+        // Probe execution harness measuring latency and memory
+    }
+}
+```
+
+### Data Collection Table:
+| Trial | Concurrency Level | Memory Usage (MB) | Execution Latency (ms) | Anomaly / Error Count |
+| :---: | :---: | :---: | :---: | :---: |
+| 1 | 1 Task | | | |
+| 2 | 10 Concurrent Tasks | | | |
+| 3 | 100 Concurrent Tasks | | | |
+| 4 | 1,000 Concurrent Tasks | | | |
+
+---
+
+## [REQUIRED] CER Scientific Conclusion (Claim, Evidence, Reasoning)
+> *Students must write their conclusion strictly following the 3-part CER framework:*
+
+### 1. 📌 Claim (Khẳng định):
+- *Direct answer to the driving question in 1 concise sentence:*  
+  ```text
+  [E.g., "Actor-based state isolation completely eliminates data race crashes while maintaining sub-16ms latency up to 500 concurrent operations."]
+  ```
+
+### 2. 📊 Evidence (Bằng chứng số liệu):
+- *Specific quantitative data points cited directly from the Data Collection Table:*  
+  ```text
+  [E.g., "In Trial 3 with 100 concurrent tasks, the unprotected array crashed 4 out of 5 times, whereas the Actor implementation completed with 0 errors in an average of 12.4ms."]
+  ```
+
+### 3. 🧠 Reasoning (Lập luận khoa học):
+- *Connect the evidence back to the underlying technical principle:*  
+  ```text
+  [E.g., "This occurs because the Actor mailbox serializes incoming asynchronous message invocations via cooperative multitasking on the dispatch pool, ensuring that only one thread can mutate internal state at any given CPU tick."]
+  ```
+
+---
+
+## [REQUIRED] Peer Review & Verification Protocol
+- **Reproducibility Test:** Exchange code probes with another student group to verify if their experimental results match within a $\pm 10\%$ tolerance band.