@thanh01.pmt/curriculum-kit 1.4.35 → 1.4.37

package/dist/index.cjs

@@ -3574,6 +3574,50 @@ var ScaffoldDecisionEntrySchema = zod.z.object({
   minutes_saved: zod.z.number().int().nonnegative().default(0),
   reason: zod.z.string().min(3)
 });
+var ZpdVerdictSchema = zod.z.enum(["OK", "TOO_MANY_NEW", "NO_ZPD_BRIDGE"]);
+var SessionZpdStatusSchema = zod.z.object({
+  verdict: ZpdVerdictSchema,
+  new_concept_count: zod.z.number().int().nonnegative().default(0),
+  known_concept_count: zod.z.number().int().nonnegative().default(0),
+  issues: zod.z.array(zod.z.string()).default([])
+});
+var ConceptSpiralEncounterSchema = zod.z.object({
+  concept_code: zod.z.string(),
+  session_id: LessonCodeSchema,
+  encounter_index: zod.z.number().int().positive(),
+  bloom_cap: BloomLevelSchema,
+  depth: DepthLevelSchema
+});
+var WalkingSkeletonSchema = zod.z.object({
+  epitome_unit_id: zod.z.string().default("U01"),
+  epitome_deliverables: zod.z.array(zod.z.string()).default([]),
+  elaborations: zod.z.array(zod.z.object({
+    unit_id: zod.z.string(),
+    focus_area: zod.z.string(),
+    elaborates_on: zod.z.array(zod.z.string()).default([])
+  })).default([])
+});
+var MasteryGateSchema = zod.z.object({
+  phase_or_unit_id: zod.z.string(),
+  gate_name: zod.z.string(),
+  exit_criteria: zod.z.array(zod.z.string()).min(1),
+  next_unit_id: zod.z.string(),
+  remediation: zod.z.object({
+    trigger: zod.z.literal("FAIL_GATE_CRITERIA"),
+    focus_minutes: zod.z.number().int().default(15),
+    action: zod.z.string()
+  })
+});
+var ConceptPrerequisiteEdgeSchema = zod.z.object({
+  concept_code: zod.z.string(),
+  requires: zod.z.string(),
+  source: zod.z.enum(["MASTER_TREE", "INFERRED", "CONCEPT_LEVEL_PREREQ"]).default("CONCEPT_LEVEL_PREREQ"),
+  confidence: zod.z.number().min(0).max(1).default(0.8),
+  rationale: zod.z.string().default(""),
+  structure_supported: zod.z.boolean().default(true),
+  needs_review: zod.z.boolean().default(false),
+  hub: zod.z.boolean().default(false)
+});
 var SessionPlanSchema = zod.z.object({
   id: LessonCodeSchema,
   unit_id: zod.z.string().regex(/^U\d{2}$/),
@@ -3594,7 +3638,14 @@ var SessionPlanSchema = zod.z.object({
   scaffold_decisions: zod.z.array(ScaffoldDecisionEntrySchema).default([]),
   // What the student can demonstrate after this session — feeds exit tickets.
   exit_evidence: zod.z.array(zod.z.string()).min(1),
-  differentiation: zod.z.object({ bronze: zod.z.string(), silver: zod.z.string(), gold: zod.z.string() })
+  differentiation: zod.z.object({ bronze: zod.z.string(), silver: zod.z.string(), gold: zod.z.string() }),
+  // P50: ZPD cognitive load status for this session
+  zpd_status: SessionZpdStatusSchema.default({
+    verdict: "OK",
+    new_concept_count: 0,
+    known_concept_count: 0,
+    issues: []
+  })
 });
 var TranslationPolicySchema = zod.z.object({
   policy: zod.z.enum(["after_artifact", "end_of_unit", "at_publish", "native"]).default("native"),
@@ -3649,6 +3700,11 @@ var CurriculumPlanSchema = zod.z.object({
   // [2]
   sessions: zod.z.array(SessionPlanSchema).min(1),
   // [3][4][5][6]
+  // P50: Macro-pedagogical course structures
+  walking_skeleton: WalkingSkeletonSchema.optional(),
+  mastery_gates: zod.z.array(MasteryGateSchema).default([]),
+  concept_spiral_progression: zod.z.array(ConceptSpiralEncounterSchema).default([]),
+  concept_prerequisites: zod.z.array(ConceptPrerequisiteEdgeSchema).default([]),
   glossary_scope: zod.z.array(zod.z.object({
     session_id: LessonCodeSchema,
     terms: zod.z.array(zod.z.string())
@@ -11279,7 +11335,8 @@ function parseAllSessions(plan, frameworkMarkdown) {
         prose_objective: s.prose_objective || s.objective || "",
         new_keywords: Array.isArray(s.new_keywords) ? s.new_keywords : Array.isArray(s.keywords) ? s.keywords : [],
         prerequisite_keywords: Array.isArray(s.prerequisite_keywords) ? s.prerequisite_keywords : [],
-        depth_assignments: Array.isArray(s.depth_assignments) ? s.depth_assignments : []
+        depth_assignments: Array.isArray(s.depth_assignments) ? s.depth_assignments : [],
+        zpd_status: s.zpd_status
       }));
     }
   }
@@ -11427,12 +11484,16 @@ async function extractCurriculumHorizon(opts) {
     title: s.title,
     keywords: s.new_keywords || []
   }));
+  const rawSpirals = Array.isArray(plan?.concept_spiral_progression) ? plan.concept_spiral_progression : [];
+  const sessionSpirals = rawSpirals.filter((e) => e.session_id === targetLessonId);
   return {
     targetLessonId,
     targetLessonIndex: targetIndex + 1,
     totalLessons: sessions.length,
     targetTitle: currentSession.title,
     targetKeywords: currentSession.new_keywords || [],
+    zpdStatus: currentSession.zpd_status,
+    spiralProgression: sessionSpirals,
     compactMasterySet: {
       masteredKeywords,
       masteredConcepts
@@ -11448,6 +11509,8 @@ function renderHorizonPromptBlock(horizon) {
     totalLessons,
     targetTitle,
     targetKeywords,
+    zpdStatus,
+    spiralProgression,
     compactMasterySet,
     detailedBridge,
     boundaryPeek
@@ -11455,6 +11518,19 @@ function renderHorizonPromptBlock(horizon) {
   const lines = [
     `# \u{1F9ED} CURRICULUM HORIZON & SCAFFOLDING MATRIX (Lesson ${targetLessonIndex}/${totalLessons}: "${targetTitle}" [${targetLessonId}])`
   ];
+  if (zpdStatus && zpdStatus.verdict !== "OK") {
+    lines.push(
+      `
+> \u26A0\uFE0F **ZPD COGNITIVE LOAD ALERT (${zpdStatus.verdict}):** ${zpdStatus.issues?.join("; ") || "Scaffolding bridge mandated"}. Introduce minimal new syntax and anchor into known concepts.`
+    );
+  }
+  if (spiralProgression && spiralProgression.length > 0) {
+    const spiralNotes = spiralProgression.map(
+      (sp) => `\`${sp.concept_code}\` (Encounter #${sp.encounter_index}): Bloom Cap [${sp.bloom_cap}], Depth [${sp.depth.toUpperCase()}]`
+    );
+    lines.push(`
+- **\u{1F300} Bruner Spiral Curricula Guidance:** ${spiralNotes.join(" | ")}`);
+  }
   if (compactMasterySet.masteredKeywords.length > 0 || compactMasterySet.masteredConcepts.length > 0) {
     const rawKeywords = compactMasterySet.masteredKeywords;
     const displayedKeywords = rawKeywords.length > 20 ? rawKeywords.slice(-20) : rawKeywords;
@@ -11625,9 +11701,9 @@ function buildSectionAwareExcerpt(markdown, opts = {}) {
     if (s.canonicalKey && !byCanonical.has(s.canonicalKey)) {
       byCanonical.set(s.canonicalKey, s);
     }
-    const norm = normalizeHeading(s.cleanTitle);
-    if (!byCleanTitle.has(norm)) {
-      byCleanTitle.set(norm, s);
+    const norm2 = normalizeHeading(s.cleanTitle);
+    if (!byCleanTitle.has(norm2)) {
+      byCleanTitle.set(norm2, s);
     }
     if (!s.canonicalKey) {
       unmatched.push(s);
@@ -11765,8 +11841,8 @@ function parseMarkdownSections(markdown, slcMap, artifactType) {
   const flush = () => {
     if (!currentHeading) return;
     const cleanTitle = currentHeading.replace(/^#{1,4}\s+/, "").trim();
-    const norm = normalizeHeading(cleanTitle);
-    const canonicalKey = reverseMap.get(norm) || findCanonicalFuzzy(norm);
+    const norm2 = normalizeHeading(cleanTitle);
+    const canonicalKey = reverseMap.get(norm2) || findCanonicalFuzzy(norm2);
     sections.push({
       rawHeading: currentHeading,
       cleanTitle,
@@ -11792,49 +11868,55 @@ function parseMarkdownSections(markdown, slcMap, artifactType) {
 function normalizeHeading(str) {
   return str.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
-function findCanonicalFuzzy(norm) {
-  if (norm.includes("toolchain") || norm.includes("moi truong phat trien") || norm.includes("cong cu") || norm.includes("version") || norm.includes("phan mem") || norm.includes("development environment") || norm.includes("technical overview") || norm.includes("kien truc")) {
+function findCanonicalFuzzy(norm2) {
+  if (norm2.includes("toolchain") || norm2.includes("moi truong phat trien") || norm2.includes("cong cu") || norm2.includes("version") || norm2.includes("phan mem") || norm2.includes("development environment") || norm2.includes("technical overview") || norm2.includes("kien truc")) {
     return "Technical Overview & Architecture Blueprint";
   }
-  if (norm.includes("pinout") || norm.includes("phan cung") || norm.includes("hardware") || norm.includes("wiring") || norm.includes("ket noi")) {
+  if (norm2.includes("pinout") || norm2.includes("phan cung") || norm2.includes("hardware") || norm2.includes("wiring") || norm2.includes("ket noi")) {
     return "Hardware Pinout & Wiring Configuration Matrix";
   }
-  if (norm.includes("pedagog") || norm.includes("phuong phap") || norm.includes("day hoc") || norm.includes("su pham")) {
+  if (norm2.includes("pedagog") || norm2.includes("phuong phap") || norm2.includes("day hoc") || norm2.includes("su pham")) {
     return "Core Pedagogical Concept Anchor & Real-World Domain Bridge";
   }
-  if (norm.includes("standard") || norm.includes("tieu chuan") || norm.includes("csta") || norm.includes("cs2023") || norm.includes("chuan academic")) {
+  if (norm2.includes("standard") || norm2.includes("tieu chuan") || norm2.includes("csta") || norm2.includes("cs2023") || norm2.includes("chuan academic")) {
     return "Standards Alignment";
   }
-  if (norm.includes("roadmap") || norm.includes("lo trinh") || norm.includes("milestone") || norm.includes("giai doan")) {
+  if (norm2.includes("roadmap") || norm2.includes("lo trinh") || norm2.includes("milestone") || norm2.includes("giai doan")) {
     return void 0;
   }
-  if (norm.includes("symbol") || norm.includes("identifier ledger") || norm.includes("dinh danh")) {
+  if (norm2.includes("symbol") || norm2.includes("identifier ledger") || norm2.includes("dinh danh")) {
     return "Symbol & Identifier Ledger";
   }
-  if (norm.includes("artifact contract") || norm.includes("hop dong hoc lieu")) {
+  if (norm2.includes("artifact contract") || norm2.includes("hop dong hoc lieu")) {
     return "Artifact Contract";
   }
-  if (norm.includes("lesson design plan") || norm.includes("ke hoach thiet ke")) {
+  if (norm2.includes("lesson design plan") || norm2.includes("ke hoach thiet ke")) {
     return "A. Lesson Design Plan";
   }
-  if (norm.includes("lesson flow") || norm.includes("tien trinh giang day")) {
+  if (norm2.includes("lesson flow") || norm2.includes("tien trinh giang day")) {
     return "B. Lesson Flow";
   }
-  if (norm.includes("learning objective") || norm.includes("muc tieu bai hoc")) {
+  if (norm2.includes("learning objective") || norm2.includes("muc tieu bai hoc")) {
     return "Learning Objectives & Evidence";
   }
-  if (norm.includes("activity sequence") || norm.includes("chuoi hoat dong")) {
+  if (norm2.includes("activity sequence") || norm2.includes("chuoi hoat dong")) {
     return "Activity Sequence";
   }
-  if (norm.includes("key term") || norm.includes("thuat ngu")) {
+  if (norm2.includes("key term") || norm2.includes("thuat ngu")) {
     return "Key Terms";
   }
-  if (norm.includes("concept narrative") || norm.includes("dien giai khai niem")) {
+  if (norm2.includes("concept narrative") || norm2.includes("dien giai khai niem")) {
     return "Concept Narratives";
   }
-  if (norm.includes("worked example") || norm.includes("vi du")) {
+  if (norm2.includes("worked example") || norm2.includes("vi du")) {
     return "Worked Micro-Examples";
   }
+  if (norm2.includes("common mistake") || norm2.includes("loi thuong gap") || norm2.includes("sai lam") || norm2.includes("pitfall")) {
+    return "Common Mistakes";
+  }
+  if (norm2.includes("self check") || norm2.includes("self-check") || norm2.includes("tu kiem tra")) {
+    return "Self-Check Questions";
+  }
   return void 0;
 }
 function truncateByBudget(source, budget) {
@@ -12769,7 +12851,7 @@ function decideScaffolds(session, nodeById, warnings) {
   return decisions;
 }
 var DEPTH_NEXT = { ulo: "cio", cio: "sio", sio: "sio" };
-function assignDepths(nodeIds, nodeById) {
+function assignDepths(nodeIds, nodeById, conceptEncounterMap) {
   const assignments = [];
   let lastDepth = null;
   for (const id of nodeIds) {
@@ -12777,8 +12859,14 @@ function assignDepths(nodeIds, nodeById) {
     let depth;
     let source;
     if (node.kind === "concept") {
+      const primaryCode = node.concept_codes[0];
+      const encounters = primaryCode && conceptEncounterMap ? conceptEncounterMap.get(primaryCode) ?? 1 : 1;
       const advanced = node.phase_id !== "" && /__ADV\d{2}$/.test(node.id);
-      depth = advanced ? "sio" : "cio";
+      if (encounters >= 2 || advanced) {
+        depth = "sio";
+      } else {
+        depth = "cio";
+      }
       source = "planner";
     } else {
       depth = node.depth_hint ?? "cio";
@@ -12793,6 +12881,201 @@ function assignDepths(nodeIds, nodeById) {
   }
   return assignments;
 }
+function computeConceptSpiralProgression(sessions, nodeById) {
+  const encounters = [];
+  const conceptCounts = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const sessionConcepts = [...new Set(s.node_ids.flatMap((id) => nodeById.get(id)?.concept_codes || []))];
+    for (const cCode of sessionConcepts) {
+      const count = (conceptCounts.get(cCode) || 0) + 1;
+      conceptCounts.set(cCode, count);
+      let bloomCap;
+      let depth;
+      if (count === 1) {
+        bloomCap = "Understand";
+        depth = "cio";
+      } else if (count === 2) {
+        bloomCap = "Apply";
+        depth = "sio";
+      } else {
+        bloomCap = "Analyze";
+        depth = "sio";
+      }
+      encounters.push({
+        concept_code: cCode,
+        session_id: s.id,
+        encounter_index: count,
+        bloom_cap: bloomCap,
+        depth
+      });
+    }
+  }
+  return encounters;
+}
+function checkSessionZpd(sessionIndex, nodeIds, nodeById, allSeenConcepts, allSeenKeywords, entryKw, warnings) {
+  const concepts = [...new Set(nodeIds.flatMap((id) => nodeById.get(id)?.concept_codes || []))];
+  const newConcepts = concepts.filter((c) => !allSeenConcepts.has(c));
+  const knownConcepts = concepts.filter((c) => allSeenConcepts.has(c));
+  const allKeywords = [...new Set(nodeIds.flatMap((id) => nodeById.get(id)?.keywords || []))];
+  const newKeywords = allKeywords.filter((k) => !allSeenKeywords.has(k.toLowerCase()) && !entryKw.has(k.toLowerCase()));
+  const knownKeywords = allKeywords.filter((k) => allSeenKeywords.has(k.toLowerCase()) || entryKw.has(k.toLowerCase()));
+  const issues = [];
+  let verdict = "OK";
+  if (concepts.length > 0 && newConcepts.length > 2) {
+    verdict = "TOO_MANY_NEW";
+    issues.push(`${newConcepts.length} new concepts exceed ZPD limit (max 2)`);
+  } else if (concepts.length === 0 && newKeywords.length > 4) {
+    verdict = "TOO_MANY_NEW";
+    issues.push(`${newKeywords.length} new keywords exceed ZPD limit (max 4)`);
+  }
+  if (sessionIndex > 0) {
+    if (concepts.length > 1 && knownConcepts.length === 0) {
+      verdict = "NO_ZPD_BRIDGE";
+      issues.push("No known concepts from previous sessions to bridge new learning");
+    } else if (concepts.length === 0 && allKeywords.length > 2 && knownKeywords.length === 0) {
+      verdict = "NO_ZPD_BRIDGE";
+      issues.push("No known keywords from previous sessions to bridge new learning");
+    }
+  }
+  let bridgeRepair;
+  if (verdict === "NO_ZPD_BRIDGE" && (allSeenConcepts.size > 0 || allSeenKeywords.size > 0)) {
+    const bridgeAnchor = [...allSeenConcepts].pop() || [...allSeenKeywords].pop() || "prior knowledge";
+    bridgeRepair = {
+      node_id: nodeIds[0],
+      decision: "recap_in_lesson",
+      reason: `ZPD self-healing: recap anchor (${bridgeAnchor}) to bridge into new material`
+    };
+    warnings.push(`ZPD bridge self-healing: session ${sessionIndex + 1} injected recap anchor (${bridgeAnchor})`);
+  }
+  for (const c of concepts) allSeenConcepts.add(c);
+  for (const k of allKeywords) allSeenKeywords.add(k.toLowerCase());
+  return {
+    status: {
+      verdict,
+      new_concept_count: concepts.length > 0 ? newConcepts.length : newKeywords.length,
+      known_concept_count: concepts.length > 0 ? knownConcepts.length : knownKeywords.length,
+      issues
+    },
+    bridgeRepair
+  };
+}
+function buildWalkingSkeleton(units, sessions) {
+  const epitomeUnit = units[0];
+  const epitomeId = epitomeUnit?.id || "U01";
+  const epitomeDeliverables = sessions.filter((s) => s.unit_id === epitomeId).flatMap((s) => s.exit_evidence || []).slice(0, 8);
+  const elaborations = units.slice(1).map((u) => ({
+    unit_id: u.id,
+    focus_area: u.name,
+    elaborates_on: epitomeDeliverables.slice(0, 3)
+  }));
+  return {
+    epitome_unit_id: epitomeId,
+    epitome_deliverables: epitomeDeliverables,
+    elaborations
+  };
+}
+function buildMasteryGates(units, sessions) {
+  const gates = [];
+  for (let i = 0; i < units.length - 1; i++) {
+    const cur = units[i];
+    const next = units[i + 1];
+    const unitEvidence = sessions.filter((s) => s.unit_id === cur.id).flatMap((s) => s.exit_evidence || []).slice(0, 6);
+    gates.push({
+      phase_or_unit_id: cur.id,
+      gate_name: `${cur.name} Mastery Gate`,
+      exit_criteria: unitEvidence.length > 0 ? unitEvidence : [`Master all deliverables for ${cur.name}`],
+      next_unit_id: next.id,
+      remediation: {
+        trigger: "FAIL_GATE_CRITERIA",
+        focus_minutes: 15,
+        action: `Review and complete failing practical criteria for ${cur.name} before starting ${next.name}`
+      }
+    });
+  }
+  return gates;
+}
+function dropCyclicConceptEdges(edges) {
+  const pairSet = new Set(edges.map((e) => `${e.concept_code}|${e.requires}`));
+  const nonSymmetric = edges.filter((e) => !pairSet.has(`${e.requires}|${e.concept_code}`));
+  const deps = /* @__PURE__ */ new Map();
+  const createsCycle = (a, b) => {
+    const stack = [b];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n === a) return true;
+      if (seen.has(n)) continue;
+      seen.add(n);
+      const targets = deps.get(n);
+      if (targets) {
+        for (const t of targets) stack.push(t);
+      }
+    }
+    return false;
+  };
+  const out = [];
+  for (const e of nonSymmetric) {
+    if (createsCycle(e.concept_code, e.requires)) continue;
+    if (!deps.has(e.concept_code)) deps.set(e.concept_code, /* @__PURE__ */ new Set());
+    deps.get(e.concept_code).add(e.requires);
+    out.push(e);
+  }
+  return out;
+}
+function buildConceptPrerequisites(sessions, nodeById, edges) {
+  const firstSeen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sessions.length; i++) {
+    const s = sessions[i];
+    for (const nid of s.node_ids) {
+      const codes = nodeById.get(nid)?.concept_codes || [];
+      for (const c of codes) {
+        if (!firstSeen.has(c)) firstSeen.set(c, i);
+      }
+    }
+  }
+  const rawEdges = [];
+  const seenPair = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    const fromNode = nodeById.get(e.from);
+    const toNode = nodeById.get(e.to);
+    if (!fromNode || !toNode) continue;
+    const fromCodes = fromNode.concept_codes || [];
+    const toCodes = toNode.concept_codes || [];
+    for (const tc of toCodes) {
+      for (const fc of fromCodes) {
+        if (tc === fc) continue;
+        const key = `${tc}|${fc}`;
+        if (seenPair.has(key)) continue;
+        seenPair.add(key);
+        const firstSeenTc = firstSeen.get(tc) ?? 999;
+        const firstSeenFc = firstSeen.get(fc) ?? 999;
+        const supported = firstSeenFc <= firstSeenTc;
+        rawEdges.push({
+          concept_code: tc,
+          requires: fc,
+          source: "CONCEPT_LEVEL_PREREQ",
+          confidence: supported ? 0.8 : 0.6,
+          rationale: e.reason || `Derived from planning node dependency: ${fromNode.name} -> ${toNode.name}`,
+          structure_supported: supported,
+          needs_review: !supported,
+          hub: false
+        });
+      }
+    }
+  }
+  const fanOut = /* @__PURE__ */ new Map();
+  for (const re of rawEdges) {
+    fanOut.set(re.concept_code, (fanOut.get(re.concept_code) || 0) + 1);
+  }
+  for (const re of rawEdges) {
+    if ((fanOut.get(re.concept_code) || 0) >= 6) {
+      re.hub = true;
+      re.confidence = Math.min(re.confidence, 0.5);
+      re.needs_review = true;
+    }
+  }
+  return dropCyclicConceptEdges(rawEdges);
+}
 async function buildCurriculumPlan(rawGraph, options) {
   const { constraints } = options;
   const warnings = [];
@@ -12888,6 +13171,9 @@ async function buildCurriculumPlan(rawGraph, options) {
   const seenNodes = /* @__PURE__ */ new Set();
   const multiPartNodes = new Set(packed.flatMap((s) => s.entries.filter((e) => e.totalParts > 1).map((e) => e.id)));
   const sessions = [];
+  const allSeenConcepts = /* @__PURE__ */ new Set();
+  const allSeenKeywords = /* @__PURE__ */ new Set();
+  const conceptEncounterMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < packed.length; i++) {
     const s = packed[i];
     for (const id of s.nodeIds) {
@@ -12932,6 +13218,16 @@ async function buildCurriculumPlan(rawGraph, options) {
       knowledge: s.knowledgeMinutes || 0,
       practice: s.practiceMinutes + (s.practiceMinutes === 0 && s.knowledgeMinutes > 0 ? Math.min(spareMinutes, 10) : 0)
     };
+    const sessionConcepts = [...new Set(s.nodeIds.flatMap((id) => nodeById.get(id)?.concept_codes || []))];
+    for (const cCode of sessionConcepts) {
+      const curCount = (conceptEncounterMap.get(cCode) || 0) + 1;
+      conceptEncounterMap.set(cCode, curCount);
+    }
+    const zpdResult = checkSessionZpd(i, s.nodeIds, nodeById, allSeenConcepts, allSeenKeywords, entryKw, warnings);
+    const prereqDecisions = decidePrerequisites(ctx, nodeById, graph.edges, sessionIndexByNode, sessionOrderByIndex, constraints);
+    if (zpdResult.bridgeRepair) {
+      prereqDecisions.unshift(zpdResult.bridgeRepair);
+    }
     sessions.push({
       id: lessonCode,
       unit_id: unit.id,
@@ -12952,8 +13248,8 @@ async function buildCurriculumPlan(rawGraph, options) {
       //    Spiral pedagogy = apply at greater depth, not re-lecture.
       practice_minutes: sessionMinutes.practice,
       overhead_minutes: spec.overheadMinutes,
-      depth_assignments: assignDepths(s.nodeIds, nodeById),
-      prerequisite_decisions: decidePrerequisites(ctx, nodeById, graph.edges, sessionIndexByNode, sessionOrderByIndex, constraints),
+      depth_assignments: assignDepths(s.nodeIds, nodeById, conceptEncounterMap),
+      prerequisite_decisions: prereqDecisions,
       scaffold_decisions: decideScaffolds(ctx, nodeById, warnings),
       // Deliverable phrasing follows the node role: concept → evidence is the
       // explanation, product_step/skill → the artifact or activity itself.
@@ -12968,16 +13264,58 @@ async function buildCurriculumPlan(rawGraph, options) {
         bronze: "Complete the core deliverable for " + nodeNames[0] + " with provided scaffolding.",
         silver: "Complete all session deliverables independently.",
         gold: "Extend the deliverable: combine " + nodeNames.join(", ") + " in a self-chosen variant."
-      }
+      },
+      // P50: ZPD cognitive load status for this session
+      zpd_status: zpdResult.status
     });
   }
   const unassigned = graph.nodes.map((n) => n.id).filter((id) => !seenNodes.has(id));
   if (unassigned.length > 0) throw new Error("Coverage violation: unassigned nodes " + unassigned.join(", "));
+  if (options.llmFn && sessions.length > 0) {
+    try {
+      const sessionSummaries = sessions.map((s) => `${s.id}|${s.title}|objective: ${s.prose_objective.slice(0, 120)}|keywords: ${s.new_keywords.join("/")}`).join("\n");
+      const dSys = 'You differentiate learning tasks. Output ONLY a JSON object mapping session-id to {"bronze":string,"silver":string,"gold":string}. Each tier ONE sentence: bronze = foundational task with provided scaffolding; silver = independent application; gold = creative extension combining session concepts. Same language as the objectives.';
+      const dUsr = `Age band: ${constraints.age_band[0]}-${constraints.age_band[1]}. Entry level: ${constraints.entry_level}.
+Sessions:
+${sessionSummaries}`;
+      const raw = (await options.llmFn(dSys, dUsr)).trim();
+      const match = raw.match(/\{[\s\S]*\}/);
+      if (match) {
+        const parsed = JSON.parse(match[0]);
+        let upgraded = 0;
+        for (const s of sessions) {
+          const d = parsed[s.id];
+          if (d && typeof d.bronze === "string" && d.bronze.length >= 10 && typeof d.silver === "string" && d.silver.length >= 10 && typeof d.gold === "string" && d.gold.length >= 10) {
+            s.differentiation = { bronze: d.bronze, silver: d.silver, gold: d.gold };
+            upgraded++;
+          }
+        }
+        if (upgraded < sessions.length) warnings.push(`differentiation_llm_partial:${upgraded}/${sessions.length}`);
+      } else {
+        warnings.push("differentiation_llm_unparseable");
+      }
+    } catch (e) {
+      warnings.push("differentiation_llm_failed:" + (e instanceof Error ? e.message.slice(0, 80) : String(e).slice(0, 80)));
+    }
+  }
   const glossaryScope = sessions.map((s) => ({
     session_id: s.id,
     terms: [...new Set(s.node_ids.flatMap((id) => nodeById.get(id).keywords))]
   }));
-  const planPayload = { units, sessions, course: { objectives: courseObjectives }, constraints };
+  const conceptSpiralProgression = computeConceptSpiralProgression(sessions, nodeById);
+  const walkingSkeleton = buildWalkingSkeleton(units, sessions);
+  const masteryGates = buildMasteryGates(units, sessions);
+  const conceptPrerequisites = buildConceptPrerequisites(sessions, nodeById, graph.edges);
+  const planPayload = {
+    units,
+    sessions,
+    course: { objectives: courseObjectives },
+    constraints,
+    walking_skeleton: walkingSkeleton,
+    mastery_gates: masteryGates,
+    concept_spiral_progression: conceptSpiralProgression,
+    concept_prerequisites: conceptPrerequisites
+  };
   const planHash = crypto.createHash("sha256").update(JSON.stringify(planPayload)).digest("hex").slice(0, 16);
   const plan = CurriculumPlanSchema.parse({
     schema_version: 1,
@@ -12989,6 +13327,10 @@ async function buildCurriculumPlan(rawGraph, options) {
     course: { objectives: courseObjectives, capstone_ref: constraints.capstone },
     units,
     sessions,
+    walking_skeleton: walkingSkeleton,
+    mastery_gates: masteryGates,
+    concept_spiral_progression: conceptSpiralProgression,
+    concept_prerequisites: conceptPrerequisites,
     glossary_scope: glossaryScope,
     translation: options.translation ?? { policy: "at_publish", target_language: null },
     coverage_report: { assigned_node_ids: [...seenNodes], unassigned_node_ids: [], warnings },
@@ -13020,6 +13362,13 @@ function buildSessionSliceContext(plan, lessonCode) {
   lines.push("- Prerequisite keywords: " + (s.prerequisite_keywords.join(", ") || "(none)"));
   lines.push("- Time split: knowledge " + s.knowledge_minutes + "m / practice " + s.practice_minutes + "m / overhead " + s.overhead_minutes + "m");
   lines.push("- Depth assignments: " + s.depth_assignments.map((d) => d.node_id + "=" + d.depth.toUpperCase() + "(" + d.source + ")").join("; "));
+  if (s.zpd_status && s.zpd_status.verdict !== "OK") {
+    lines.push("- ZPD alert: " + s.zpd_status.verdict + " (" + s.zpd_status.issues.join("; ") + ")");
+  }
+  const sessionSpirals = (plan.concept_spiral_progression || []).filter((e) => e.session_id === lessonCode);
+  if (sessionSpirals.length > 0) {
+    lines.push("- Spiral encounters: " + sessionSpirals.map((e) => `${e.concept_code}#${e.encounter_index}=${e.bloom_cap}(${e.depth.toUpperCase()})`).join("; "));
+  }
   if (s.prerequisite_decisions.length > 0) {
     lines.push("- Prerequisite decisions [" + s.prerequisite_decisions.length + "]:");
     for (const d of s.prerequisite_decisions) lines.push("  * " + d.node_id + ": " + d.decision + " \u2014 " + d.reason);
@@ -13341,14 +13690,14 @@ function lintFrameworkPack(pack) {
     const primaryLang = pack.manifest.languages[0];
     const text = s.texts[primaryLang];
     if (!text) continue;
-    const norm = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2).sort().join(" ");
-    if (!norm) continue;
-    const prev = seen.get(norm);
+    const norm2 = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2).sort().join(" ");
+    if (!norm2) continue;
+    const prev = seen.get(norm2);
     if (prev !== void 0) {
       issues.push({ severity: "WARNING", code: "DUP_TEXT_EXACT", message: `Text is token-identical to statement "${prev}"`, ref: s.id });
     } else {
       for (const [otherNorm, otherId] of seen.entries()) {
-        const a = new Set(norm.split(" "));
+        const a = new Set(norm2.split(" "));
         const b = new Set(otherNorm.split(" "));
         let inter = 0;
         for (const w of a) if (b.has(w)) inter++;
@@ -13358,7 +13707,7 @@ function lintFrameworkPack(pack) {
           break;
         }
       }
-      seen.set(norm, s.id);
+      seen.set(norm2, s.id);
     }
   }
   for (const m of pack.mappings ?? []) {
@@ -26099,6 +26448,263 @@ function extractStandardRefs(text) {
   return Array.from(new Set(matches));
 }
 
+// src/services/contextSlots.ts
+var LESSON_SLOT_BUDGETS = {
+  ACT: { budget: 8e3 },
+  GUIDE: { budget: 6e3 },
+  QUIZ: { budget: 3500, priorities: ["A. Lesson Design Plan"] },
+  SLIDE: { budget: 4500, priorities: ["B. Lesson Flow", "A. Lesson Design Plan"] },
+  WKS: { budget: 4500, priorities: ["A. Lesson Design Plan", "B. Lesson Flow"] },
+  EXIT_TICKET: { budget: 3e3, priorities: ["A. Lesson Design Plan", "B. Lesson Flow"] }
+};
+var KX_ONLY_TYPES = /* @__PURE__ */ new Set(["CODE", "HANDOUT", "EXT"]);
+var KX_SLOT_PRIORITIES = {
+  QUIZ: ["Common Mistakes", "Self-Check Questions", "Key Terms", "Concept Narratives"],
+  EXIT_TICKET: ["Self-Check Questions", "Key Terms"],
+  WKS: ["Self-Check Questions", "Worked Micro-Examples", "Key Terms"],
+  CODE: ["Worked Micro-Examples", "Key Terms", "Common Mistakes"],
+  GUIDE: ["Common Mistakes", "Key Terms", "Concept Narratives"],
+  HANDOUT: ["Key Terms", "Concept Narratives", "Common Mistakes"],
+  SLIDE: ["Key Terms", "Worked Micro-Examples"],
+  ACT: ["Worked Micro-Examples", "Common Mistakes"],
+  EXT: ["Worked Micro-Examples", "Common Mistakes"]
+};
+var norm = (s) => s.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "");
+function extractActivityContractRows(lessonContent, artifactType, maxChars = 1500) {
+  if (!lessonContent) return "";
+  const wanted = norm(artifactType).replace(/_/g, "");
+  const lines = lessonContent.split("\n");
+  let inSeq = false;
+  const headerRows = [];
+  const matchedRows = [];
+  const allRows = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const h = line.match(/^#{2,4}\s+(.*)$/);
+    if (h) {
+      const t2 = h[1];
+      if (/activity\s*sequence/i.test(t2)) inSeq = true;
+      else if (inSeq) break;
+      continue;
+    }
+    if (!inSeq) continue;
+    const t = line.trim();
+    if (!t.startsWith("|")) continue;
+    if (/^\|\s*[-: |]+\|\s*$/.test(t)) continue;
+    const cells = t.split("|").slice(1, -1).map((c) => c.trim());
+    if (cells.length >= 4) {
+      if (headerRows.length === 0) {
+        headerRows.push(t);
+        continue;
+      }
+      allRows.push(t);
+      const contract = cells[cells.length - 1] ?? "";
+      const candidates = contract.split(/[,;/]/).map((c) => norm(c));
+      if (candidates.some((c) => c === wanted || c.length > 3 && (c.includes(wanted) || wanted.includes(c)))) {
+        matchedRows.push(t);
+      }
+    }
+  }
+  const rows = matchedRows.length > 0 ? matchedRows : allRows.slice(0, 3);
+  if (rows.length === 0) return "";
+  let out = headerRows[0] ?? "";
+  for (const r of rows) {
+    if (out.length + r.length + 1 > maxChars) break;
+    out += "\n" + r;
+  }
+  return out;
+}
+function extractTieredScaffoldingBlock(lessonContent, maxChars = 900) {
+  if (!lessonContent) return "";
+  const lines = lessonContent.split("\n");
+  let capture = null;
+  for (const line of lines) {
+    const h = line.match(/^#{2,4}\s+(.*)$/);
+    if (h) {
+      const isTierHeading = /elaborate|tiered|scaffold/i.test(h[1] ?? "");
+      if (capture && !isTierHeading) break;
+      if (isTierHeading) capture = [];
+      continue;
+    }
+    if (capture) {
+      capture.push(line);
+      if (capture.join("").length >= maxChars) break;
+    }
+  }
+  const body = (capture ?? []).join("\n").trim();
+  return body ? body.slice(0, maxChars) : "";
+}
+function extractAssessmentMap(lessonContent, maxChars = 1200) {
+  if (!lessonContent) return "";
+  const lines = lessonContent.split("\n");
+  let capture = null;
+  for (const line of lines) {
+    const h = line.match(/^#{2,4}\s+(.*)$/);
+    if (h) {
+      const isTarget = /assessment\s*map/i.test(h[1] ?? "");
+      if (capture && !isTarget) break;
+      if (isTarget) capture = [];
+      continue;
+    }
+    if (capture) {
+      capture.push(line);
+      if (capture.join("").length >= maxChars) break;
+    }
+  }
+  const body = (capture ?? []).join("\n").trim();
+  return body ? body.slice(0, maxChars) : "";
+}
+function blockMeta(slot, source, text, verified, issues = []) {
+  return { slot, source, chars: text.length, verified, issues };
+}
+function buildSatelliteContext(input) {
+  const {
+    artifactType,
+    commonContext,
+    lessonContent,
+    lessonExcerpt,
+    expositionContent,
+    slcMarkdown,
+    symbolLedgerBlock,
+    pedagogyLabel,
+    mode = "legacy"
+  } = input;
+  const type = (artifactType || "").toUpperCase().trim();
+  if (mode === "legacy" || type === "LESSON") {
+    const context2 = `${commonContext}
+
+[CANONICAL LESSON PLAN (${pedagogyLabel ?? "LESSON"})]:
+${lessonExcerpt.excerpt}${symbolLedgerBlock}`;
+    return {
+      context: context2,
+      blocks: [
+        blockMeta("commonContext", "COMPOSITE", commonContext, true),
+        blockMeta("lessonExcerpt", "LESSON", lessonExcerpt.excerpt, lessonExcerpt.verified, lessonExcerpt.issues)
+      ],
+      verified: lessonExcerpt.verified,
+      sectionAware: lessonExcerpt.sectionAware,
+      issues: lessonExcerpt.issues,
+      tokenEstimate: Math.round(context2.length / 4),
+      canonicalExcerpt: lessonExcerpt.excerpt
+    };
+  }
+  const blocks = [];
+  const issues = [];
+  const parts = [commonContext];
+  blocks.push(blockMeta("commonContext", "COMPOSITE", commonContext, true));
+  let excerptSlot;
+  let miniSlot;
+  const compositeHasKx = /###\s+KNOWLEDGE_EXPOSITION/.test(commonContext);
+  if (expositionContent.trim() && !compositeHasKx) {
+    const kxExcerpt = buildSectionAwareExcerpt(expositionContent, {
+      priorities: KX_SLOT_PRIORITIES[type] ?? ["Key Terms", "Concept Narratives", "Worked Micro-Examples"],
+      budget: 4500,
+      sectionLanguageContract: slcMarkdown,
+      artifactType: "KNOWLEDGE_EXPOSITION"
+    });
+    parts.push(`
+
+[KNOWLEDGE_EXPOSITION (canonical knowledge \u2014 teach from this, do not contradict; scoped for ${type})]:
+${kxExcerpt.excerpt}`);
+    blocks.push(blockMeta("kxExcerpt:" + type, "KNOWLEDGE_EXPOSITION", kxExcerpt.excerpt, kxExcerpt.verified, kxExcerpt.issues));
+    if (!kxExcerpt.verified) issues.push(...kxExcerpt.issues.map((i) => `kx:${i}`));
+  }
+  if (!KX_ONLY_TYPES.has(type)) {
+    const spec = LESSON_SLOT_BUDGETS[type] ?? { budget: 12e3 };
+    const excerpt = buildSectionAwareExcerpt(lessonContent, {
+      priorities: spec.priorities ?? ["Artifact Contract", "A. Lesson Design Plan", "B. Lesson Flow", "Learning Objectives & Evidence", "Activity Sequence"],
+      budget: spec.budget,
+      sectionLanguageContract: slcMarkdown,
+      artifactType: "LESSON"
+    });
+    const excerptBlock = `
+
+[CANONICAL LESSON PLAN (scoped for ${type})]:
+${excerpt.excerpt}`;
+    parts.push(excerptBlock);
+    excerptSlot = excerptBlock;
+    blocks.push(blockMeta("lessonExcerpt:" + type, "LESSON", excerpt.excerpt, excerpt.verified, excerpt.issues));
+    if (!excerpt.verified) issues.push(...excerpt.issues.map((i) => `lesson:${i}`));
+    if (type === "QUIZ" || type === "WKS") {
+      const am = extractAssessmentMap(lessonContent, 1200);
+      if (am) {
+        parts.push(`
+
+[ASSESSMENT MAP (criteria anchor \u2014 assess exactly these)]:
+${am}`);
+        blocks.push(blockMeta("assessmentMap:" + type, "LESSON", am, true));
+      } else {
+        issues.push(`assessment-map:unresolved:${type}`);
+      }
+    }
+    if (symbolLedgerBlock) {
+      parts.push(symbolLedgerBlock);
+      blocks.push(blockMeta("symbolLedger", "LESSON", symbolLedgerBlock, true));
+    }
+  } else {
+    const contractRows = extractActivityContractRows(lessonContent, type === "CODE" ? "CODE_LAB" : type, 1500);
+    const tierBlock = type === "CODE" || type === "EXT" ? extractTieredScaffoldingBlock(lessonContent, 900) : "";
+    const mini = [
+      contractRows ? `### Activity Sequence rows assigned to ${type} (canonical \u2014 do not invent a different task):
+${contractRows}` : "",
+      tierBlock ? `### Tiered task ladder (from LESSON Elaborate phase):
+${tierBlock}` : ""
+    ].filter(Boolean).join("\n\n");
+    if (mini) {
+      const miniBlock = `
+
+[LESSON ACTIVITY CONTRACT (mini-slot)]:
+${mini}`;
+      parts.push(miniBlock);
+      miniSlot = miniBlock;
+      blocks.push(blockMeta("activityContract:" + type, "LESSON", mini, true));
+    } else {
+      issues.push(`activity-contract:unresolved:${type}`);
+      blocks.push(blockMeta("activityContract:" + type, "LESSON", "", false, ["no-matching-rows"]));
+    }
+    if (type === "CODE" && symbolLedgerBlock) {
+      parts.push(symbolLedgerBlock);
+      blocks.push(blockMeta("symbolLedger", "LESSON", symbolLedgerBlock, true));
+    }
+  }
+  const context = parts.join("");
+  return {
+    context,
+    blocks,
+    verified: blocks.filter((b) => b.slot !== "commonContext").every((b) => b.verified),
+    sectionAware: blocks.some((b) => b.slot.startsWith("lessonExcerpt") || b.slot.startsWith("kxExcerpt")),
+    issues,
+    tokenEstimate: Math.round(context.length / 4),
+    // Judge ground truth = exactly what THIS type consumed (scoped or mini slot).
+    canonicalExcerpt: (miniSlot ?? excerptSlot ?? lessonExcerpt.excerpt).trim()
+  };
+}
+var ACTIVITY_ALIGNMENT_LOG_ONLY_UNTIL = /* @__PURE__ */ new Date("2026-09-23T00:00:00Z");
+function isActivityAlignmentLogOnly(now = /* @__PURE__ */ new Date()) {
+  const env = (process.env.DRIFT_ALIGNMENT_LOG_ONLY ?? "").toLowerCase().trim();
+  if (env === "false" || env === "0") return false;
+  if (env === "true" || env === "1") return true;
+  return now < ACTIVITY_ALIGNMENT_LOG_ONLY_UNTIL;
+}
+function evaluateActivityAlignment(canonicalExcerpt, generatedContent, now = /* @__PURE__ */ new Date()) {
+  const mode = isActivityAlignmentLogOnly(now) ? "log_only" : "enforcing";
+  if (!canonicalExcerpt || !canonicalExcerpt.trim()) {
+    return { checked: false, passed: null, matchedTokens: [], missingTokens: [], mode };
+  }
+  const content = (generatedContent || "").toLowerCase();
+  const stripped = canonicalExcerpt.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  const latin = Array.from(new Set(stripped.match(/[a-z][a-z0-9_]{3,}/g) ?? []));
+  const cjk = Array.from(new Set(canonicalExcerpt.match(/[\u4e00-\u9fff]{2,}/g) ?? []));
+  const tokens = [...latin, ...cjk];
+  if (tokens.length === 0) {
+    return { checked: false, passed: null, matchedTokens: [], missingTokens: [], mode };
+  }
+  const matchedTokens = tokens.filter((t) => content.includes(t));
+  const missingTokens = tokens.filter((t) => !content.includes(t));
+  const passed = matchedTokens.length > 0;
+  return { checked: true, passed, matchedTokens: matchedTokens.slice(0, 10), missingTokens: missingTokens.slice(0, 10), mode };
+}
+
 // src/services/lessonProductionService.ts
 var __filename2 = typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) === "string" && typeof url.fileURLToPath === "function" ? url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))) : "";
 var _resolvedDir = __filename2 ? path3__default.default.dirname(__filename2) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
@@ -26671,9 +27277,9 @@ ${renderHorizonPromptBlock(horizon)}`;
     console.warn(`[produceSingleLesson] Notice: Curriculum Horizon extraction:`, hErr?.message || hErr);
   }
   let productSpecBlock = "";
-  const buildGroundTruthBlock = () => {
+  const buildGroundTruthBlock = (includeKx = true) => {
     const parts = [];
-    if (expositionContext) {
+    if (includeKx && expositionContext) {
       parts.push(`### KNOWLEDGE_EXPOSITION (CANONICAL KNOWLEDGE \u2014 teach from this, do not contradict)
 ${expositionContext}`);
     }
@@ -26707,10 +27313,10 @@ ${sessionSliceContext}` : "";
   const guardrailBlock = `
 
 ${platformGuardrail}`;
-  const assembleCommonContext = (sg) => `${baseContextPrefix}
+  const assembleCommonContext = (sg, includeKx = true) => `${baseContextPrefix}
 
 [CONTENT STYLE GUIDE EXCERPT]:
-${sg}${standardsBlock}${glossaryBlock}${buildGroundTruthBlock()}${sessionSliceBlock}${horizonBlock}${guardrailBlock}`;
+${sg}${standardsBlock}${glossaryBlock}${buildGroundTruthBlock(includeKx)}${sessionSliceBlock}${horizonBlock}${guardrailBlock}`;
   let commonContext = assembleCommonContext(effectiveStyleGuide);
   const MAX_COMPOSITE_PROMPT_CHARS = 3e4;
   const runnerOptions = options.customInference ? { customInference: options.customInference } : {};
@@ -27119,10 +27725,34 @@ ${currentContent}` }],
 - Entry Source File: \`${symbolLedger.entryFileName || symbolLedger.primarySymbol}\`
 - Key Identifiers to inherit verbatim: ${symbolLedger.keySymbols.map((s) => `\`${s}\``).join(", ")}
 - INVARIANT: You MUST use these exact identifier names in all code examples, exercises, and test assertions. Do NOT invent new struct/class names!` : "";
-  const satelliteContext = `${commonContext}
-
-[CANONICAL LESSON PLAN (${pedagogyLabel})]:
-${lessonExcerpt}${symbolLedgerBlock}`;
+  const routingMode = options.contextRoutingMode ?? "legacy";
+  const kxFreeCommonContext = routingMode === "hybrid" ? assembleCommonContext(effectiveStyleGuide, false) : "";
+  const satelliteContexts = {};
+  const satelliteContextMeta = {};
+  const satelliteContextFor = (artifactType) => {
+    const key = artifactType.toUpperCase();
+    if (!satelliteContexts[key]) {
+      const built = buildSatelliteContext({
+        artifactType: key,
+        commonContext: routingMode === "hybrid" ? kxFreeCommonContext : commonContext,
+        lessonContent,
+        lessonExcerpt: lessonExcerptResult,
+        expositionContent: expositionContext,
+        slcMarkdown,
+        symbolLedgerBlock,
+        pedagogyLabel,
+        mode: routingMode
+      });
+      satelliteContexts[key] = built.context;
+      satelliteContextMeta[key] = built;
+      onProgress?.(
+        "@content",
+        `[CONTEXT] ${key} satellite context: ${built.context.length} chars (${built.blocks.map((b) => `${b.slot}:${b.chars}`).join(", ")})`,
+        { type: "progress", promptChars: built.context.length, artifactType: key }
+      );
+    }
+    return satelliteContexts[key];
+  };
   const judgeSat = (sat, content) => {
     if (gateModeFor(gates, sat) !== "LLM_JUDGE") return Promise.resolve();
     const det = validateArtifactDeterministic({ content, refPack });
@@ -27142,6 +27772,30 @@ ${lessonExcerpt}${symbolLedgerBlock}`;
         }
       });
     }
+    const slotMeta = satelliteContextMeta[sat.toUpperCase()];
+    if (slotMeta) {
+      const alignment = evaluateActivityAlignment(slotMeta.canonicalExcerpt, content);
+      if (alignment.checked && alignment.passed === false) {
+        const note = `activity-alignment drift vs ${sat} contract slot (matched: ${alignment.matchedTokens.join(", ") || "none"}); canonical tokens absent from output`;
+        if (alignment.mode === "enforcing") {
+          const critique = validatorRepairPrompt([{ code: "scope-drift", detail: note, evidence: alignment.missingTokens }]);
+          onProgress?.("@reviewer", `\u26D4 ${sat} activity-alignment drift FAIL: ${note}`);
+          return storage.updateArtifactState(projectId, lessonCode, sat, {
+            state: "rejected",
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            contentHash: computeContentHash(content),
+            review: {
+              decision: "NEEDS_REVISION",
+              reviewedBy: "@heuristic-linter",
+              reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              score: 0,
+              critique
+            }
+          });
+        }
+        onProgress?.("@reviewer", `\u{1F9ED} [log-only] ${sat} activity-alignment drift: ${note}`);
+      }
+    }
     return judgeSatelliteArtifact({
       storage,
       projectId,
@@ -27154,7 +27808,7 @@ ${lessonExcerpt}${symbolLedgerBlock}`;
       onProgress,
       targetLang,
       canonicalLessonContent: lessonContent,
-      canonicalLessonExcerpt: lessonExcerpt
+      canonicalLessonExcerpt: slotMeta?.canonicalExcerpt ?? lessonExcerpt
     });
   };
   const actRelPath = `_content/${unitCode}/ACT_${lessonCode}.md`;
@@ -27203,7 +27857,7 @@ ${languageDirective}
 ${buildHeadingDirective("ACT", slcMarkdown, targetLang)}`;
     const rawAct = await runCurriculumAIInference(
       [{ role: "user", content: actPrompt }],
-      satelliteContext,
+      satelliteContextFor("ACT"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@activity", chunk, { type: type || "content", artifactType: "ACT" });
@@ -27273,7 +27927,7 @@ ${languageDirective}
 ${buildHeadingDirective("QUIZ", slcMarkdown, targetLang)}`;
     const rawQuiz = await runCurriculumAIInference(
       [{ role: "user", content: quizPrompt }],
-      satelliteContext,
+      satelliteContextFor("QUIZ"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@assessor", chunk, { type: type || "content", artifactType: "QUIZ" });
@@ -27326,7 +27980,7 @@ ${buildHeadingDirective("QUIZ", slcMarkdown, targetLang)}`;
         headingDirective: buildHeadingDirective("SLIDE", slcMarkdown, targetLang),
         groundContext: slideGroundContext,
         productSpecBlock: productSpecBlock || void 0,
-        satelliteContext,
+        satelliteContext: satelliteContextFor("SLIDE"),
         runnerOptions,
         onProgress: (agent, msg, meta) => {
           options.onProgress?.(agent, msg, meta || { type: "content", artifactType: "SLIDE" });
@@ -27410,7 +28064,7 @@ footer: "Curriculum OS \u2022 ${lessonCode} (${pedagogyLabel})"
       });
       const rawSlide = await runCurriculumAIInference(
         [{ role: "user", content: slidePrompt }],
-        satelliteContext,
+        satelliteContextFor("SLIDE"),
         runnerOptions,
         (chunk, type) => {
           options.onProgress?.("@illustrator", chunk, { type: type || "content", artifactType: "SLIDE" });
@@ -27471,7 +28125,7 @@ ${languageDirective}
 ${buildHeadingDirective("GUIDE", slcMarkdown, targetLang)}`;
     const rawGuide = await runCurriculumAIInference(
       [{ role: "user", content: guidePrompt }],
-      satelliteContext,
+      satelliteContextFor("GUIDE"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@content", chunk, { type: type || "chunk", artifactType: "GUIDE" });
@@ -27523,7 +28177,7 @@ ${languageDirective}
 ${buildHeadingDirective("HANDOUT", slcMarkdown, targetLang)}`;
     const rawHandout = await runCurriculumAIInference(
       [{ role: "user", content: handoutPrompt }],
-      satelliteContext,
+      satelliteContextFor("HANDOUT"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@content", chunk, { type: type || "chunk", artifactType: "HANDOUT" });
@@ -27579,7 +28233,7 @@ ${languageDirective}
 ${buildHeadingDirective("WKS", slcMarkdown, targetLang)}`;
     const rawWks = await runCurriculumAIInference(
       [{ role: "user", content: wksPrompt }],
-      satelliteContext,
+      satelliteContextFor("WKS"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@content", chunk, { type: type || "chunk", artifactType: "WKS" });
@@ -27639,7 +28293,7 @@ ${languageDirective}
 ${buildHeadingDirective("CODE", slcMarkdown, targetLang)}`;
     const rawCode = await runCurriculumAIInference(
       [{ role: "user", content: codePrompt }],
-      satelliteContext,
+      satelliteContextFor("CODE"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@activity", chunk, { type: type || "chunk", artifactType: "CODE" });
@@ -27726,7 +28380,7 @@ ${languageDirective}
 ${buildHeadingDirective("EXT", slcMarkdown, targetLang)}`;
     const rawExt = await runCurriculumAIInference(
       [{ role: "user", content: extPrompt }],
-      satelliteContext,
+      satelliteContextFor("EXT"),
       runnerOptions,
       (chunk, type) => {
         options.onProgress?.("@activity", chunk, { type: type || "chunk", artifactType: "EXT" });
@@ -30826,6 +31480,75 @@ var DeterministicStructuralLinter = class {
       strengths
     };
   }
+  /**
+   * P50: Validates macro-pedagogical invariants across a CurriculumPlan.
+   * Checks:
+   * 1. ZPD violations without self-healing recap (NO_ZPD_BRIDGE)
+   * 2. Walking Skeleton existence (Unit 1 delivers working software)
+   * 3. Inter-unit Mastery Gate presence
+   */
+  static lintPlan(plan) {
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    for (const s of plan.sessions) {
+      if (s.zpd_status?.verdict === "TOO_MANY_NEW") {
+        score -= 10;
+        findings.push({
+          id: `PLAN_TOO_MANY_NEW_${s.id}`,
+          dimension: "CONSTRUCTIVE_ALIGNMENT",
+          severity: "MINOR",
+          title: `Cognitive Overload in Session ${s.id}`,
+          description: s.zpd_status.issues.join("; ") || `Session introduces too many new concepts/keywords, exceeding ZPD capacity.`,
+          remediationAdvice: `Distribute new concepts across multiple sessions or introduce via scaffolding.`,
+          affectedElement: s.id
+        });
+      } else if (s.zpd_status?.verdict === "NO_ZPD_BRIDGE") {
+        const hasRecap = s.prerequisite_decisions.some((d) => d.decision === "recap_in_lesson");
+        if (!hasRecap) {
+          score -= 15;
+          findings.push({
+            id: `PLAN_NO_ZPD_BRIDGE_${s.id}`,
+            dimension: "CONSTRUCTIVE_ALIGNMENT",
+            severity: "MAJOR",
+            title: `Unhealed ZPD Bridge in Session ${s.id}`,
+            description: `Session introduces new concepts with 0 known concept bridges, and lacks recap scaffolding.`,
+            remediationAdvice: `Add a recap_in_lesson prerequisite decision to anchor new learning in prior concepts.`,
+            affectedElement: s.id
+          });
+        }
+      }
+    }
+    if (!plan.walking_skeleton || plan.walking_skeleton.epitome_deliverables.length === 0) {
+      score -= 10;
+      findings.push({
+        id: "PLAN_MISSING_WALKING_SKELETON",
+        dimension: "CONSTRUCTIVE_ALIGNMENT",
+        severity: "MINOR",
+        title: "Missing Walking Skeleton Definition",
+        description: "Plan does not declare an Epitome (walking skeleton) in Unit 1.",
+        remediationAdvice: "Ensure Unit 1 defines minimal end-to-end deliverables."
+      });
+    } else {
+      strengths.push(`Unit ${plan.walking_skeleton.epitome_unit_id} establishes an end-to-end Walking Skeleton (Epitome).`);
+    }
+    if (plan.units.length > 1 && (!plan.mastery_gates || plan.mastery_gates.length === 0)) {
+      score -= 10;
+      findings.push({
+        id: "PLAN_MISSING_MASTERY_GATES",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: "MINOR",
+        title: "Missing Inter-Unit Mastery Gates",
+        description: "Multi-unit course lacks formal transition gates between units.",
+        remediationAdvice: "Define exit criteria and remediation sprints for each inter-unit boundary."
+      });
+    } else if (plan.mastery_gates && plan.mastery_gates.length > 0) {
+      strengths.push(`${plan.mastery_gates.length} inter-unit Mastery Gates defined with remediation protocols.`);
+    }
+    score = Math.max(0, Math.min(100, score));
+    const passed = score >= 80 && !findings.some((f) => f.severity === "CRITICAL");
+    return { passed, score, findings, strengths };
+  }
 };
 
 // src/evaluators/academicAuditor.ts
@@ -32496,6 +33219,8 @@ exports.CodeLabSchema = CodeLabSchema;
 exports.CodeSnippetSchema = CodeSnippetSchema;
 exports.CompetencyRubricRowSchema = CompetencyRubricRowSchema;
 exports.ComputationalThinkingSchema = ComputationalThinkingSchema;
+exports.ConceptPrerequisiteEdgeSchema = ConceptPrerequisiteEdgeSchema;
+exports.ConceptSpiralEncounterSchema = ConceptSpiralEncounterSchema;
 exports.ConstructiveAlignmentEvaluator = ConstructiveAlignmentEvaluator;
 exports.CoreConceptSchema = CoreConceptSchema;
 exports.CourseObjectiveSchema = CourseObjectiveSchema;
@@ -32570,6 +33295,7 @@ exports.LessonSectionSchema = LessonSectionSchema;
 exports.LocalWorkspaceManager = LocalWorkspaceManager;
 exports.MappingKindSchema = MappingKindSchema;
 exports.MarpSlideSchema = MarpSlideSchema;
+exports.MasteryGateSchema = MasteryGateSchema;
 exports.MediaError = MediaError;
 exports.MediaLedger = MediaLedger;
 exports.MentorCheatsheetSchema = MentorCheatsheetSchema;
@@ -32623,6 +33349,7 @@ exports.SelfLabSchema = SelfLabSchema;
 exports.SelfPacedBundleSchema = SelfPacedBundleSchema;
 exports.SelfPacedChallengeSchema = SelfPacedChallengeSchema;
 exports.SessionPlanSchema = SessionPlanSchema;
+exports.SessionZpdStatusSchema = SessionZpdStatusSchema;
 exports.SilverTierSchema = SilverTierSchema;
 exports.SlideDeckSchema = SlideDeckSchema;
 exports.StandardizedTermRowSchema = StandardizedTermRowSchema;
@@ -32647,20 +33374,24 @@ exports.TroubleshootingRowSchema = TroubleshootingRowSchema;
 exports.UnitPlanSchema = UnitPlanSchema;
 exports.UserJourneySchema = UserJourneySchema;
 exports.WORKSHEET_TEMPLATE = WORKSHEET_TEMPLATE;
+exports.WalkingSkeletonSchema = WalkingSkeletonSchema;
 exports.WorksheetItemSchema = WorksheetItemSchema;
 exports.WorksheetItemTypeEnum = WorksheetItemTypeEnum;
 exports.WorksheetPartSchema = WorksheetPartSchema;
 exports.WorksheetSchema = WorksheetSchema;
+exports.ZpdVerdictSchema = ZpdVerdictSchema;
 exports.activityTools = activityTools;
 exports.analystTools = analystTools;
 exports.analyzeProjectCreationIntent = analyzeProjectCreationIntent;
 exports.assertAcyclic = assertAcyclic;
 exports.assessorTools = assessorTools;
+exports.assignDepths = assignDepths;
 exports.atomicWriteFileSync = atomicWriteFileSync;
 exports.auditCurriculumQualityFlow = auditCurriculumQualityFlow;
 exports.auditQualityReport = auditQualityReport;
 exports.buildActivityPrompt = buildActivityPrompt;
 exports.buildCodeLabPrompt = buildCodeLabPrompt;
+exports.buildConceptPrerequisites = buildConceptPrerequisites;
 exports.buildCurriculumContext = buildCurriculumContext;
 exports.buildCurriculumPlan = buildCurriculumPlan;
 exports.buildDeliveryPackages = buildDeliveryPackages;
@@ -32678,7 +33409,9 @@ exports.buildLanguageDirective = buildLanguageDirective;
 exports.buildLessonExcerpt = buildLessonExcerpt;
 exports.buildLessonMasterPrompt = buildLessonMasterPrompt;
 exports.buildMarpMarkdownSlidePrompt = buildMarpMarkdownSlidePrompt;
+exports.buildMasteryGates = buildMasteryGates;
 exports.buildProjectInstructionPrompt = buildProjectInstructionPrompt;
+exports.buildSatelliteContext = buildSatelliteContext;
 exports.buildSectionAwareExcerpt = buildSectionAwareExcerpt;
 exports.buildSelfLabPrompt = buildSelfLabPrompt;
 exports.buildSessionSliceContext = buildSessionSliceContext;
@@ -32687,8 +33420,11 @@ exports.buildStandardStackMarkdown = buildStandardStackMarkdown;
 exports.buildStandardsContext = buildStandardsContext;
 exports.buildStandardsContextBlock = buildStandardsContextBlock;
 exports.buildTeacherGuidePrompt = buildTeacherGuidePrompt;
+exports.buildWalkingSkeleton = buildWalkingSkeleton;
 exports.buildWorksheetPrompt = buildWorksheetPrompt;
+exports.checkSessionZpd = checkSessionZpd;
 exports.closeTruncatedJson = closeTruncatedJson;
+exports.computeConceptSpiralProgression = computeConceptSpiralProgression;
 exports.computeContentHash = computeContentHash;
 exports.computePackingSpec = computePackingSpec;
 exports.conductPreliminaryResearch = conductPreliminaryResearch;
@@ -32704,14 +33440,18 @@ exports.createStreamChunkExtractor = createStreamChunkExtractor;
 exports.curateMediaLedger = curateMediaLedger;
 exports.designerTools = designerTools;
 exports.detectProjectPedagogy = detectProjectPedagogy;
+exports.dropCyclicConceptEdges = dropCyclicConceptEdges;
 exports.emitUsage = emitUsage;
 exports.ensureExpositionForLesson = ensureExpositionForLesson;
 exports.ensureKnowledgeExposition = ensureKnowledgeExposition;
+exports.evaluateActivityAlignment = evaluateActivityAlignment;
 exports.evaluateStandardsCoverage = evaluateStandardsCoverage;
 exports.executeCurriculumCommand = executeCurriculumCommand;
 exports.executeSlideProductionWorkflow = executeSlideProductionWorkflow;
 exports.exportAllProjectQuizzes = exportAllProjectQuizzes;
 exports.expositionCacheKey = expositionCacheKey;
+exports.extractActivityContractRows = extractActivityContractRows;
+exports.extractAssessmentMap = extractAssessmentMap;
 exports.extractCurriculumHorizon = extractCurriculumHorizon;
 exports.extractJsonArray = extractJsonArray;
 exports.extractScopeSequenceRows = extractScopeSequenceRows;
@@ -32721,6 +33461,7 @@ exports.extractStandardRefs = extractStandardRefs;
 exports.extractStreamChunk = extractStreamChunk;
 exports.extractSymbolLedger = extractSymbolLedger;
 exports.extractThoughtAndContent = extractThoughtAndContent;
+exports.extractTieredScaffoldingBlock = extractTieredScaffoldingBlock;
 exports.findStandardStatement = findStandardStatement;
 exports.formatQuizzesToCsv = formatQuizzesToCsv;
 exports.fulfillMediaLedger = fulfillMediaLedger;
@@ -32760,6 +33501,7 @@ exports.importRoadmapToProject = importRoadmapToProject;
 exports.ingestProjectGraphIntoProject = ingestProjectGraphIntoProject;
 exports.initializeProjectInStorage = initializeProjectInStorage;
 exports.injectMediaIntoMarkdown = injectMediaIntoMarkdown;
+exports.isActivityAlignmentLogOnly = isActivityAlignmentLogOnly;
 exports.isExpositionFresh = isExpositionFresh;
 exports.isModelAllowed = isModelAllowed;
 exports.isProviderEnabled = isProviderEnabled;