@thanh01.pmt/curriculum-kit 1.0.12 → 1.0.14

package/dist/index.cjs

@@ -14,7 +14,6 @@ var supabaseJs = require('@supabase/supabase-js');
 var url = require('url');
 var jsonrepair = require('jsonrepair');
 var rest = require('@octokit/rest');
-var workflow = require('workflow');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -13525,6 +13524,78 @@ var DeterministicPipelineRunner = class {
 
 // src/services/prefillService.ts
 init_streamRunner();
+var DEFAULT_STREAM_IDLE_MS = 45e3;
+var DEFAULT_STREAM_TOTAL_MS = 3e5;
+var LAYER_TOTAL_BUDGET_MS = {
+  1: 18e4,
+  2: 36e4,
+  3: 36e4
+};
+function resolveStreamBudget(layer, opts) {
+  const envIdle = Number(process.env.WIZARD_PREFILL_IDLE_TIMEOUT_MS);
+  const envTotal = Number(process.env.WIZARD_PREFILL_TOTAL_TIMEOUT_MS);
+  const layerTotal = layer !== void 0 ? LAYER_TOTAL_BUDGET_MS[layer] : void 0;
+  return {
+    idleMs: opts?.idleMs ?? (Number.isFinite(envIdle) && envIdle > 0 ? envIdle : DEFAULT_STREAM_IDLE_MS),
+    totalMs: opts?.totalMs ?? (Number.isFinite(envTotal) && envTotal > 0 ? envTotal : layerTotal ?? DEFAULT_STREAM_TOTAL_MS)
+  };
+}
+function extractStreamChunk(part) {
+  if (!part || typeof part !== "object") return {};
+  if (part.type === "reasoning-delta" || part.type === "reasoning") {
+    const thought = part.text ?? part.delta ?? part.reasoning ?? "";
+    return thought ? { thought } : {};
+  }
+  if (part.type === "text-delta") {
+    const content = part.text ?? part.delta ?? "";
+    return content ? { content } : {};
+  }
+  if (part.type === "raw") {
+    const raw = part.rawValue;
+    const delta = raw?.choices?.[0]?.delta;
+    const reasoning = delta?.reasoning_content ?? delta?.reasoning ?? raw?.delta?.reasoning_content ?? raw?.delta?.reasoning;
+    if (typeof reasoning === "string" && reasoning) return { thought: reasoning };
+    const text = delta?.content ?? raw?.delta?.content;
+    if (typeof text === "string" && text) return { content: text };
+    return {};
+  }
+  return {};
+}
+function createStreamAbortSignal(budget) {
+  const controller = new AbortController();
+  let idleTimer = null;
+  let totalTimer = null;
+  const armIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (budget.idleMs > 0) {
+      idleTimer = setTimeout(
+        () => controller.abort(new Error(`Idle timeout: no data for ${Math.round(budget.idleMs / 1e3)}s`)),
+        budget.idleMs
+      );
+      idleTimer?.unref?.();
+    }
+  };
+  armIdle();
+  if (budget.totalMs > 0) {
+    totalTimer = setTimeout(
+      () => controller.abort(new Error(`Total stream timeout after ${Math.round(budget.totalMs / 1e3)}s`)),
+      budget.totalMs
+    );
+    totalTimer?.unref?.();
+  }
+  return {
+    signal: controller.signal,
+    /** Reset the idle window — call on EVERY received stream part. */
+    kick: armIdle,
+    /** Clear both timers once the stream lifecycle is over. */
+    dispose: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      if (totalTimer) clearTimeout(totalTimer);
+      idleTimer = null;
+      totalTimer = null;
+    }
+  };
+}
 function safeParseJson(rawText) {
   if (!rawText) return null;
   const cleaned = rawText.replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
@@ -13549,7 +13620,7 @@ function safeParseJson(rawText) {
     return null;
   }
 }
-async function streamLLMWithFallback(systemPrompt, userPrompt, apiKeys = {}, onChunk, preferredModel, preferredProvider) {
+async function streamLLMWithFallback(systemPrompt, userPrompt, apiKeys = {}, onChunk, preferredModel, preferredProvider, budget) {
   const alibabaKey = apiKeys.alibaba || apiKeys.dashscope || process.env.ALIBABA_API_KEY || process.env.DASHSCOPE_API_KEY;
   const nvidiaKey = apiKeys.nvidia || process.env.NVIDIA_API_KEY;
   const deepseekKey = apiKeys.deepseek || process.env.DEEPSEEK_API_KEY;
@@ -13627,8 +13698,13 @@ async function streamLLMWithFallback(systemPrompt, userPrompt, apiKeys = {}, onC
   const systemInstructions = `${systemPrompt}
 
 THINKING DIRECTIVE: Keep reasoning concise, structured, and focused strictly on the core pedagogical trade-offs in 4-6 concise bullet points (under 120 words). Then output the JSON immediately.`;
+  const resolvedBudget = {
+    idleMs: budget?.idleMs ?? DEFAULT_STREAM_IDLE_MS,
+    totalMs: budget?.totalMs ?? DEFAULT_STREAM_TOTAL_MS
+  };
   for (const candidate of candidates) {
     const t0 = Date.now();
+    const abort = createStreamAbortSignal(resolvedBudget);
     try {
       const modelInstance = getAIModel({
         provider: candidate.provider,
@@ -13641,26 +13717,16 @@ THINKING DIRECTIVE: Keep reasoning concise, structured, and focused strictly on
         prompt: userPrompt,
         temperature: 0.2,
         includeRawChunks: true,
-        abortSignal: AbortSignal.timeout(6e4)
+        abortSignal: abort.signal
       });
       let fullContent = "";
       for await (const part of streamResult.fullStream) {
-        if (part.type === "reasoning-delta") {
-          const thoughtText = part.text ?? part.delta ?? "";
-          if (thoughtText) onChunk?.(thoughtText, "thought");
-        } else if (part.type === "raw") {
-          const raw = part.rawValue;
-          const delta = raw?.choices?.[0]?.delta;
-          const reasoning = delta?.reasoning_content || delta?.reasoning;
-          if (reasoning) {
-            onChunk?.(reasoning, "thought");
-          }
-        } else if (part.type === "text-delta") {
-          const textDelta = part.text ?? part.delta ?? "";
-          if (textDelta) {
-            fullContent += textDelta;
-            onChunk?.(textDelta, "content");
-          }
+        abort.kick();
+        const extracted = extractStreamChunk(part);
+        if (extracted.thought) onChunk?.(extracted.thought, "thought");
+        if (extracted.content) {
+          fullContent += extracted.content;
+          onChunk?.(extracted.content, "content");
         }
       }
       if (fullContent.trim()) {
@@ -13669,6 +13735,8 @@ THINKING DIRECTIVE: Keep reasoning concise, structured, and focused strictly on
       }
     } catch (e) {
       console.warn(`[curriculum-kit:VercelAI] Candidate ${candidate.provider} (${candidate.model}) failed in ${Date.now() - t0}ms:`, e?.message || e);
+    } finally {
+      abort.dispose();
     }
   }
   return null;
@@ -13709,7 +13777,11 @@ Return concise JSON matching:
     (chunk, type) => {
       if (type === "content") rawContent += chunk;
       onChunk?.(chunk, type);
-    }
+    },
+    options.model,
+    options.provider,
+    // Research may run live web grounding — generous budget, still idle-guarded.
+    resolveStreamBudget(void 0, { idleMs: options.idleTimeoutMs, totalMs: options.timeoutMs })
   );
   let parsedResearch = {
     groundTruthSummary: `Verified ecosystem standards for ${projectName}`,
@@ -13911,7 +13983,10 @@ REQUIREMENT: Synthesize ALL parameters above \u2014 every single line in FULL AC
       onChunk?.(chunk, type);
     },
     options.model,
-    options.provider
+    options.provider,
+    // RC-W1: layer-aware budget — Layer 2 has the largest output and free-tier
+    // models may think/stream for minutes. Idle window still catches hangs.
+    resolveStreamBudget(targetLayer, { idleMs: options.idleTimeoutMs, totalMs: options.timeoutMs })
   );
   const parsed = safeParseJson(rawContent);
   return {
@@ -14596,1014 +14671,640 @@ template_contract: "artifact-template-v1"
     timestamp: dateStr
   };
 }
-async function withRateLimitBackoff(options) {
-  let attempt = 1;
-  try {
-    const meta = workflow.getStepMetadata();
-    if (meta && typeof meta.attempt === "number") {
-      attempt = meta.attempt;
+
+// src/index.ts
+init_errors();
+
+// src/evaluators/deterministicStructuralLinter.ts
+var DeterministicStructuralLinter = class {
+  /**
+   * Validates structural invariants across a complete lesson bundle.
+   */
+  static lintBundle(input) {
+    const { lesson, quiz, activity, slides, codeLab } = input;
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    const baseLessonId = lesson.lessonId;
+    const baseLanguage = lesson.language;
+    if (!lesson.title || lesson.title.trim().length === 0) {
+      score -= 20;
+      findings.push({
+        id: "struct_missing_lesson_title",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "CRITICAL",
+        title: "Missing Lesson Title",
+        description: "Lesson plan has an empty or whitespace title.",
+        remediationAdvice: "Provide a non-empty lesson title."
+      });
     }
-  } catch {
-  }
-  try {
-    return await options.fn();
-  } catch (error) {
-    const errorMessage = error?.message || String(error);
-    const status = error?.status || error?.statusCode || error?.response?.status;
-    const isRateLimited = status === 429 || errorMessage.includes("429") || errorMessage.toLowerCase().includes("rate limit") || errorMessage.toLowerCase().includes("resource exhausted") || errorMessage.toLowerCase().includes("quota exceeded");
-    const isTransientError = status === 500 || status === 502 || status === 503 || status === 504 || errorMessage.includes("fetch failed") || errorMessage.includes("ECONNRESET") || errorMessage.includes("ETIMEDOUT") || errorMessage.includes("socket hang up");
-    if (isRateLimited || isTransientError) {
-      const retryAfterSeconds = Math.min(120, Math.pow(2, attempt) * 2);
-      const reason = isRateLimited ? "Rate limit exceeded (429)" : `Transient server error (${status || "network"})`;
-      throw new workflow.RetryableError(`[${options.stepName}] ${reason}. Retrying attempt ${attempt + 1}...`, {
-        retryAfter: `${retryAfterSeconds}s`
+    if (!lesson.learningObjectives || lesson.learningObjectives.length === 0) {
+      score -= 25;
+      findings.push({
+        id: "struct_empty_learning_objectives",
+        dimension: "CONSTRUCTIVE_ALIGNMENT",
+        severity: "CRITICAL",
+        title: "Empty Learning Objectives Array",
+        description: "Lesson plan contains 0 learning objectives.",
+        remediationAdvice: "Declare at least 2 structured Learning Objectives in the schema."
       });
     }
-    throw error;
-  }
-}
-
-// src/workflow/steps/lessonSteps.ts
-async function generateMasterLessonStep(input) {
-  "use step";
-  console.log(`  \u23F3 [Step: Master Lesson] Generating 5E Master Lesson Plan for "${input.milestone.name}"...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-master-lesson-${input.milestone.id || "L01"}`,
-    fn: async () => {
-      return generateLessonMasterFlow({
-        milestone: input.milestone,
-        language: input.language,
-        topic: input.topic,
-        targetAudience: input.targetAudience,
-        contextContinuity: input.contextContinuity,
-        standardsContext: input.standardsContext,
-        modelOptions: input.modelOptions
+    if (!lesson.sections || lesson.sections.length === 0) {
+      score -= 25;
+      findings.push({
+        id: "struct_empty_lesson_sections",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: "CRITICAL",
+        title: "Empty Lesson Sections Array",
+        description: "Lesson plan contains no instructional sections.",
+        remediationAdvice: "Provide structured lesson flow sections."
       });
     }
-  });
-  console.log(`  \u2705 [Step: Master Lesson] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Title: "${res.title}")`);
-  return res;
-}
-async function judgeMasterLessonStep(input) {
-  "use step";
-  console.log(`  \u2696\uFE0F [Step: Quality Judge] Auditing Master Lesson pedagogical quality & language adherence...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `judge-master-lesson-${input.lessonId}`,
-    fn: async () => {
-      return auditCurriculumQualityFlow({
-        targetArtifactType: "LESSON",
-        lessonId: input.lessonId,
-        expectedLanguage: input.language,
-        targetObjectives: input.targetObjectives,
-        generatedContentJson: JSON.stringify(input.lesson, null, 2),
-        standardStatements: input.standardStatements,
-        modelOptions: input.modelOptions
+    if (quiz && quiz.quizId !== baseLessonId && !quiz.quizId.includes(baseLessonId)) {
+      score -= 15;
+      findings.push({
+        id: "struct_quiz_id_mismatch",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MAJOR",
+        title: "Quiz ID Contract Mismatch",
+        description: `Quiz ID "${quiz.quizId}" does not match Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Sync Quiz quizId to "${baseLessonId}".`,
+        affectedElement: quiz.quizId
       });
     }
-  });
-  console.log(`  \u2705 [Step: Quality Judge] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Verdict: ${res.overallVerdict}, Score: ${res.totalScore}/100)`);
-  return res;
-}
-async function repairMasterLessonStep(input) {
-  "use step";
-  console.log(`  \u{1F6E0}\uFE0F [Step: Auto-Repair] Repairing Master Lesson based on Judge feedback...`);
-  const repairFeedback = `
-PREVIOUS AUDIT VERDICT: ${input.auditReport.overallVerdict} (Score: ${input.auditReport.totalScore}/100)
-Detected Issues:
-${input.auditReport.criteria.filter((c) => !c.passed).map((c) => `- [${c.name}] ${c.feedback}`).join("\n")}
-Actionable Repairs:
-${input.auditReport.actionableRepairPrompts.map((p) => `* ${p}`).join("\n")}
-Language Adherence Required: "${input.language}"
-`.trim();
-  return withRateLimitBackoff({
-    stepName: `repair-master-lesson-${input.milestone.id || "L01"}`,
-    fn: async () => {
-      return generateLessonMasterFlow({
-        milestone: input.milestone,
-        language: input.language,
-        topic: input.topic,
-        targetAudience: input.targetAudience,
-        contextContinuity: repairFeedback,
-        standardsContext: input.standardsContext,
-        modelOptions: input.modelOptions
+    if (activity && activity.lessonId !== baseLessonId) {
+      score -= 15;
+      findings.push({
+        id: "struct_act_id_mismatch",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MAJOR",
+        title: "Activity Lesson ID Contract Mismatch",
+        description: `Activity lessonId "${activity.lessonId}" does not match Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Sync Activity lessonId to "${baseLessonId}".`,
+        affectedElement: activity.lessonId
       });
     }
-  });
-}
-
-// src/workflow/steps/satelliteSteps.ts
-async function generateActivityStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Activity Lab] Generating hands-on ACT.md...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-act-${options.lesson.lessonId}`,
-    fn: async () => generateActivityFlow(options)
-  });
-  console.log(`  \u2705 [Step: Activity Lab] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Title: "${res.title}")`);
-  return res;
-}
-async function generateCodeLabStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Code Lab] Generating starter & solution code LAB.md...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-lab-${options.lesson.lessonId}`,
-    fn: async () => generateCodeLabFlow(options)
-  });
-  console.log(`  \u2705 [Step: Code Lab] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Title: "${res.title}")`);
-  return res;
-}
-async function generateSelfLabStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Self-Lab] Generating SELF_LAB.md with Progressive Hints...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-self-lab-${options.milestone.id || "L01"}`,
-    fn: async () => generateSelfLabFlow(options)
-  });
-  console.log(`  \u2705 [Step: Self-Lab] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Challenges: 3 tiers Bronze/Silver/Gold)`);
-  return res;
-}
-async function generateDiagnosticQuizStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Diagnostic Quiz] Generating QUIZ.json Bloom Assessment...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-quiz-${options.milestone.id || "L01"}`,
-    fn: async () => generateDiagnosticQuizFlow(options)
-  });
-  console.log(`  \u2705 [Step: Diagnostic Quiz] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Questions: ${res.questions.length})`);
-  return res;
-}
-async function generateSlidesStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Slides] Generating Marp presentation SLIDE.md...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-slides-${options.lesson.lessonId}`,
-    fn: async () => generateSlidesFlow(options)
-  });
-  console.log(`  \u2705 [Step: Slides] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Slides: ${res.slides.length})`);
-  return res;
-}
-async function generateHandoutStep(options) {
-  "use step";
-  console.log(`  \u23F3 [Step: Handout] Generating 5-Second Rule HANDOUT.md...`);
-  const t0 = Date.now();
-  const res = await withRateLimitBackoff({
-    stepName: `generate-handout-${options.lesson.lessonId}`,
-    fn: async () => generateHandoutFlow(options)
-  });
-  console.log(`  \u2705 [Step: Handout] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (Title: "${res.title}")`);
-  return res;
-}
-async function generateWorksheetStep(options) {
-  "use step";
-  return withRateLimitBackoff({
-    stepName: `generate-worksheet-${options.lesson.lessonId}`,
-    fn: async () => generateWorksheetFlow(options)
-  });
-}
-async function generateTeacherGuideStep(options) {
-  "use step";
-  return withRateLimitBackoff({
-    stepName: `generate-teacher-guide-${options.lesson.lessonId}`,
-    fn: async () => generateTeacherGuideFlow(options)
-  });
-}
-async function generateExtensionStep(options) {
-  "use step";
-  return withRateLimitBackoff({
-    stepName: `generate-extension-${options.lesson.lessonId}`,
-    fn: async () => generateExtensionFlow(options)
-  });
-}
-
-// src/workflow/steps/satelliteJudgeStep.ts
-async function judgeSatelliteStep(input) {
-  "use step";
-  const t0 = Date.now();
-  console.log("  \u{1F9D1}\u200D\u2696\uFE0F [Step: Satellite Judge] " + input.artifactType + " (" + input.artifactId + ")...");
-  return withRateLimitBackoff({
-    stepName: "judge-satellite-" + input.artifactType + "-" + input.artifactId,
-    fn: async () => {
-      return auditCurriculumQualityFlow({
-        targetArtifactType: input.artifactType,
-        lessonId: input.artifactId,
-        expectedLanguage: input.language,
-        targetObjectives: input.targetObjectives,
-        generatedContentJson: JSON.stringify(input.artifact),
-        standardStatements: input.standardStatements,
-        modelOptions: input.modelOptions
+    if (slides && slides.lessonId !== baseLessonId) {
+      score -= 15;
+      findings.push({
+        id: "struct_slides_id_mismatch",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MAJOR",
+        title: "Slide Deck Lesson ID Contract Mismatch",
+        description: `Slide deck lessonId "${slides.lessonId}" does not match Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Sync Slide deck lessonId to "${baseLessonId}".`,
+        affectedElement: slides.lessonId
       });
     }
-  }).then((res) => {
-    console.log("  \u2705 [Satellite Judge] " + input.artifactType + " \u2192 " + res.overallVerdict + " (" + res.totalScore + "/100) in " + ((Date.now() - t0) / 1e3).toFixed(1) + "s");
-    return res;
-  });
-}
-
-// src/workflow/steps/publishSteps.ts
-async function saveMilestoneToWorkspaceStep(input) {
-  "use step";
-  const manager = new LocalWorkspaceManager(input.baseWorkspaceDir);
-  const savedFiles = [];
-  const lessonMd = serializeLessonToMarkdown(input.lesson);
-  const p1 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "LESSON_5E.md", lessonMd, "LESSON");
-  savedFiles.push(p1);
-  if (input.activity) {
-    const actMd = serializeActivityToMarkdown(input.activity);
-    const p2 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "ACT.md", actMd, "ACT");
-    savedFiles.push(p2);
-  }
-  if (input.codeLab) {
-    const labContent = serializeCodeLabToMarkdown(input.codeLab);
-    const p3 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "LAB.md", labContent, "LAB");
-    savedFiles.push(p3);
-  }
-  if (input.selfLab) {
-    const selfLabMd = serializeSelfLabToMarkdown(input.selfLab);
-    const p4 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "SELF_LAB.md", selfLabMd, "SELF_LAB");
-    savedFiles.push(p4);
-  }
-  if (input.quiz) {
-    const quizMd = serializeDiagnosticQuizToMarkdown(input.quiz);
-    const p5a = await manager.saveArtifact(input.jobId, input.milestoneSlug, "QUIZ.md", quizMd, "QUIZ_MD");
-    const p5b = await manager.saveArtifact(
-      input.jobId,
-      input.milestoneSlug,
-      "QUIZ.json",
-      JSON.stringify(input.quiz, null, 2),
-      "QUIZ_JSON"
-    );
-    savedFiles.push(p5a, p5b);
-  }
-  if (input.slides) {
-    const slidesContent = `---
-marp: true
-theme: default
-paginate: true
----
-
-# ${input.slides.title}
-
----
-
-${input.slides.slides.map((s) => `## Slide ${s.slideNumber}: ${s.title}
-
-${s.bulletPoints.map((b) => `- ${b}`).join("\n")}${s.codeSnippet ? `
-
-\`\`\`
-${s.codeSnippet}
-\`\`\`` : ""}
-
-<!-- Presenter Notes: ${s.presenterNotes || ""} -->`).join("\n\n---\n\n")}
-`.trim();
-    const p6 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "SLIDE.md", slidesContent, "SLIDES");
-    savedFiles.push(p6);
-  }
-  if (input.handout) {
-    const handoutMd = serializeHandoutToMarkdown(input.handout);
-    const p7 = await manager.saveArtifact(input.jobId, input.milestoneSlug, "HANDOUT.md", handoutMd, "HANDOUT");
-    savedFiles.push(p7);
-  }
-  if (input.cheatSheetMarkdown) {
-    const p8 = await manager.saveArtifact(
-      input.jobId,
-      input.milestoneSlug,
-      "CHEAT_SHEET.md",
-      input.cheatSheetMarkdown,
-      "CHEAT_SHEET"
-    );
-    savedFiles.push(p8);
-  }
-  await manager.markMilestoneCompleted(input.jobId);
-  return {
-    milestoneSlug: input.milestoneSlug,
-    savedFiles
-  };
-}
-async function publishToGitStep(options) {
-  "use step";
-  return publishToGitHub(options);
-}
-async function publishToSupabaseStep(options) {
-  "use step";
-  return publishToSupabase(options);
-}
-var approvalPayloadSchema = zod.z.object({
-  approved: zod.z.boolean().describe("Whether the human reviewer approves the generated curriculum/lesson"),
-  reviewerName: zod.z.string().optional().describe("Name or ID of the reviewer"),
-  feedback: zod.z.string().optional().describe("Actionable feedback or required changes if rejected"),
-  timestamp: zod.z.string().optional().describe("ISO timestamp of the approval action")
-});
-var lessonApprovalHook = workflow.defineHook();
-function approvalHookToken(projectId, lessonId, artifactType) {
-  return `approval:${projectId}:${lessonId}:${artifactType}`;
-}
-
-// src/standards/standardsCoverageGate.ts
-function resolveStatementRef(ref, packs) {
-  const [head, ...rest] = ref.split(":");
-  const candidatePacks = rest.length > 0 ? packs.filter((p) => p.manifest.id === head) : packs;
-  const statementId = rest.length > 0 ? rest.join(":") : ref;
-  for (const p of candidatePacks) {
-    if (p.statements.some((s) => s.id === statementId)) return { pack: p, statementId };
-  }
-  return null;
-}
-function evaluateStandardsCoverage(input) {
-  const rows = [];
-  const aoToLo = /* @__PURE__ */ new Map();
-  for (const ao of input.assessmentObjectives ?? []) aoToLo.set(ao.aoCode, ao.alignedLO);
-  const loToRefs = /* @__PURE__ */ new Map();
-  for (const lo of input.objectives) {
-    loToRefs.set(lo.code, new Set(lo.standardRefs ?? []));
-  }
-  const taughtLOs = /* @__PURE__ */ new Set();
-  for (const act of input.activities ?? []) for (const lo of act.lo) taughtLOs.add(lo);
-  const assessedLOs = /* @__PURE__ */ new Set();
-  for (const q of input.quizQuestions) {
-    if (q.alignedLO) assessedLOs.add(q.alignedLO);
-    if (q.alignedAO) {
-      const lo = aoToLo.get(q.alignedAO);
-      if (lo) assessedLOs.add(lo);
+    const satellites = [
+      { type: "QUIZ", lang: quiz?.language },
+      { type: "ACT", lang: activity?.language },
+      { type: "SLIDE", lang: slides?.language }
+    ];
+    for (const sat of satellites) {
+      if (sat.lang && sat.lang.toLowerCase() !== baseLanguage.toLowerCase()) {
+        score -= 25;
+        findings.push({
+          id: `struct_language_mismatch_${sat.type}`,
+          dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+          severity: "CRITICAL",
+          title: `Language Policy Inconsistency in ${sat.type}`,
+          description: `Master Lesson is in "${baseLanguage}" but ${sat.type} is declared in "${sat.lang}".`,
+          remediationAdvice: `Set ${sat.type} language to "${baseLanguage}".`
+        });
+      }
     }
-  }
-  for (const pack of input.packs) {
-    const mappingByStatement = /* @__PURE__ */ new Map();
-    for (const m of pack.mappings ?? []) {
-      const prev = mappingByStatement.get(m.statementId);
-      if (!prev || prev !== "covers" && m.kind === "covers" || prev === "extends" && m.kind !== "extends") {
-        mappingByStatement.set(m.statementId, m.kind);
+    if (quiz && quiz.questions) {
+      for (let i = 0; i < quiz.questions.length; i++) {
+        const q = quiz.questions[i];
+        const qId = q.id || `Q${i + 1}`;
+        const options = q.options || [];
+        if (options.length < 4) {
+          score -= 10;
+          findings.push({
+            id: `struct_quiz_option_count_${qId}`,
+            dimension: "MISCONCEPTION_RIGOR",
+            severity: "MAJOR",
+            title: `Structural Option Count Error in ${qId}`,
+            description: `Question ${qId} has ${options.length} options (standard schema requires 4).`,
+            remediationAdvice: "Ensure each question has 4 options (A, B, C, D).",
+            affectedElement: qId
+          });
+        }
+        const correctCount = options.filter((o) => o.isCorrect).length;
+        if (correctCount !== 1) {
+          score -= 20;
+          findings.push({
+            id: `struct_quiz_key_count_${qId}`,
+            dimension: "MISCONCEPTION_RIGOR",
+            severity: "CRITICAL",
+            title: `Key Assignment Error in ${qId}`,
+            description: `Question ${qId} has ${correctCount} correct options (must be exactly 1).`,
+            remediationAdvice: "Set `isCorrect: true` on exactly 1 option.",
+            affectedElement: qId
+          });
+        }
       }
     }
-    for (const statement of pack.statements) {
-      const refFull = `${pack.manifest.id}:${statement.id}`;
-      const issues = [];
-      const los = input.objectives.filter((lo) => (lo.standardRefs ?? []).some((r) => r === statement.id || r === refFull)).map((lo) => lo.code);
-      const kind = mappingByStatement.get(statement.id);
-      const hasMapping = kind !== void 0;
-      const isComplianceRelevant = kind === "covers";
-      const hasActivity = los.some((lo) => taughtLOs.has(lo));
-      const hasAssessment = los.some((lo) => assessedLOs.has(lo));
-      let status;
-      if (!hasMapping) status = "UNMAPPED";
-      else if (!isComplianceRelevant) status = "PARTIAL";
-      else if (los.length > 0 && hasActivity && hasAssessment) status = "COVERED";
-      else status = "UNCOVERED";
-      if (status === "UNCOVERED") {
-        if (los.length === 0) issues.push("No learning objective anchors this statement (missing standardRefs).");
-        else {
-          if (!hasActivity) issues.push(`Anchored LO(s) ${los.join(", ")} have no activity in lesson flow.`);
-          if (!hasAssessment) issues.push(`Anchored LO(s) ${los.join(", ")} are not measured by any quiz question.`);
-        }
-      }
-      rows.push({
-        packId: pack.manifest.id,
-        statementId: statement.id,
-        statementText: Object.values(statement.texts)[0] ?? "",
-        status,
-        objectives: los,
-        hasActivity,
-        hasAssessment,
-        issues
-      });
-    }
-  }
-  for (const lo of input.objectives) {
-    for (const r of lo.standardRefs ?? []) {
-      if (!resolveStatementRef(r, input.packs)) {
-        rows.push({
-          packId: "(unresolved)",
-          statementId: r,
-          statementText: "",
-          status: "UNCOVERED",
-          objectives: [lo.code],
-          hasActivity: false,
-          hasAssessment: false,
-          issues: [`standardRef "${r}" does not exist in any adopted pack \u2014 likely a hallucinated or stale ID`]
+    if (activity?.materialsBOM?.hardware && activity.materialsBOM.hardware.length > 0) {
+      const hwText = activity.materialsBOM.hardware.join(" ").toLowerCase();
+      const hasLED = hwText.includes("led");
+      const hasResistor = hwText.includes("\u0111i\u1EC7n tr\u1EDF") || hwText.includes("resistor") || hwText.includes("220") || hwText.includes("330") || hwText.includes("1k");
+      if (hasLED && !hasResistor) {
+        score -= 20;
+        findings.push({
+          id: "struct_hardware_unsafe_led_no_resistor",
+          dimension: "TECHNICAL_AUTHENTICITY",
+          severity: "CRITICAL",
+          title: "Unsafe Circuit BOM: LED without Current-Limiting Resistor",
+          description: "Hardware BOM includes LED without a 220\u03A9-1k\u03A9 resistor, causing circuit overload.",
+          remediationAdvice: "Add a 220\u03A9 current-limiting resistor to the hardware materials list."
         });
       }
     }
-  }
-  const complianceRows = rows.filter((r) => r.status !== "UNMAPPED" && r.status !== "PARTIAL");
-  const covered = complianceRows.filter((r) => r.status === "COVERED").length;
-  const coveragePct = complianceRows.length === 0 ? 100 : Math.round(covered / complianceRows.length * 100);
-  const unresolvedCount = rows.filter((r) => r.packId === "(unresolved)").length;
-  const verdict = unresolvedCount > 0 || coveragePct < 60 ? "FAIL" : coveragePct < 100 ? "WARN" : "PASS";
-  const lines = [
-    "# Standards Coverage Report",
-    "",
-    `- Verdict: **${verdict}**`,
-    `- Compliance coverage: **${coveragePct}%** (${covered}/${complianceRows.length} "covers" statements fully taught + assessed)`,
-    `- Unresolved standardRefs: ${unresolvedCount}`,
-    "",
-    "| Pack | Statement | Status | LOs | Activity | Assessment |",
-    "|---|---|---|---|---|---|",
-    ...rows.map(
-      (r) => `|${r.packId}|${r.statementId}|${r.status}|${r.objectives.join(", ") || "\u2014"}|${r.hasActivity ? "\u2713" : "\u2717"}|${r.hasAssessment ? "\u2713" : "\u2717"}|`
-    )
-  ];
-  const issueLines = rows.filter((r) => r.issues.length > 0).flatMap((r) => r.issues.map((i) => `- [${r.packId}:${r.statementId}] ${i}`));
-  if (issueLines.length > 0) lines.push("", "## Issues", ...issueLines);
-  return {
-    verdict,
-    coveragePct,
-    rows,
-    summary: `Standards coverage ${coveragePct}% \u2014 verdict ${verdict}`,
-    rawMarkdownReport: lines.join("\n")
-  };
-}
-var StandardsRegistryAdapter = class {
-  client;
-  constructor(config = {}) {
-    if (config.client) {
-      this.client = config.client;
-      return;
-    }
-    const url = config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || "";
-    const key = config.supabaseServiceRoleKey || process.env.SUPABASE_SERVICE_ROLE_KEY || config.supabaseAnonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
-    if (!url || !key) {
-      throw new Error("StandardsRegistryAdapter: Supabase URL/key missing (pass client or env).");
-    }
-    this.client = supabaseJs.createClient(url, key);
-  }
-  // ─── Intake (write path — service role) ───────────────────────────────────
-  /** Persist a schema-validated pack as a new framework (status=draft). */
-  async importPack(pack, opts) {
-    const parsed = FrameworkPackSchema.safeParse(pack);
-    if (!parsed.success) {
-      throw new Error("importPack: pack failed schema validation: " + parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; "));
-    }
-    const p = parsed.data;
-    const { data: fw, error: fwErr } = await this.client.from("standards_frameworks").insert({
-      pack_id: p.manifest.id,
-      content_version: p.manifest.contentVersion,
-      name: p.manifest.name,
-      spec_version: p.manifest.specVersion,
-      subject: p.manifest.subject,
-      languages: p.manifest.languages,
-      grade_model: p.manifest.gradeModel,
-      provenance: p.manifest.provenance,
-      trust: p.manifest.trust,
-      status: "draft",
-      organization_code: opts?.organizationCode ?? (p.manifest.trust === "verified" ? null : p.manifest.provenance.importedBy?.replace(/^org:/, "") || null),
-      original_file_path: opts?.originalFilePath ?? null,
-      created_by: opts?.createdBy ?? null
-    }).select("id").single();
-    if (fwErr) throw new Error("importPack: framework insert failed: " + fwErr.message);
-    const frameworkId = fw.id;
-    const statementRows = p.statements.map((s) => ({
-      framework_id: frameworkId,
-      statement_id: s.id,
-      parent_statement_id: s.parentId ?? null,
-      grade_min: s.gradeBand[0],
-      grade_max: s.gradeBand[1],
-      texts: s.texts,
-      classifications: s.classifications ?? [],
-      bloom_hint: s.bloomHint ?? null,
-      keywords: s.keywords ?? [],
-      source_ref: s.sourceRef ?? null,
-      provenance: s.provenance
-    }));
-    const { error: stErr, count: stCount } = await this.client.from("standards_statements").insert(statementRows, { count: "exact" });
-    if (stErr) throw new Error("importPack: statement insert failed: " + stErr.message);
-    let mappingCount = 0;
-    if (p.mappings && p.mappings.length > 0) {
-      const mappingRows = p.mappings.map((m) => ({
-        framework_id: frameworkId,
-        statement_id: m.statementId,
-        target_ref: m.targetRef,
-        kind: m.kind,
-        confidence: m.confidence,
-        provenance: m.provenance
-      }));
-      const { error: mpErr, count: mpCount } = await this.client.from("standards_mappings").insert(mappingRows, { count: "exact" });
-      if (mpErr) throw new Error("importPack: mapping insert failed: " + mpErr.message);
-      mappingCount = mpCount ?? mappingRows.length;
+    score = Math.max(0, Math.min(100, score));
+    const passed = score >= 80 && !findings.some((f) => f.severity === "CRITICAL");
+    if (passed) {
+      strengths.push("Deterministic structure, ID contracts, and schema invariants strictly verified.");
     }
-    return { frameworkDbId: frameworkId, statementsInserted: stCount ?? statementRows.length, mappingsInserted: mappingCount };
-  }
-  /** Activate a draft framework (immutable version is now live). */
-  async activatePack(frameworkDbId) {
-    const { error } = await this.client.from("standards_frameworks").update({ status: "active" }).eq("id", frameworkDbId).eq("status", "draft");
-    if (error) throw new Error("activatePack failed: " + error.message);
-  }
-  async deprecatePack(frameworkDbId) {
-    const { error } = await this.client.from("standards_frameworks").update({ status: "deprecated" }).eq("id", frameworkDbId);
-    if (error) throw new Error("deprecatePack failed: " + error.message);
-  }
-  async adoptPack(frameworkDbId, organizationCode, adoptedBy) {
-    const { error } = await this.client.from("standards_org_adoptions").upsert(
-      { framework_id: frameworkDbId, organization_code: organizationCode, adopted_by: adoptedBy ?? null },
-      { onConflict: "organization_code,framework_id" }
-    );
-    if (error) throw new Error("adoptPack failed: " + error.message);
+    return {
+      passed,
+      structuralScore: score,
+      findings,
+      strengths
+    };
   }
-  // ─── Runtime (read path — generation) ─────────────────────────────────────
+};
+
+// src/evaluators/academicAuditor.ts
+var AcademicAuditor = class {
   /**
-   * Load all packs usable by an org: platform packs (verified, org IS NULL) +
-   * org packs + org adoptions. Hydrated into the same FrameworkPack shape the
-   * in-memory Phase-1 components consume (injector / coverage gate / judge).
+   * Evaluates a complete lesson bundle.
+   * Step 1 (Deterministic): Fast structural, contract, schema, and safety linting.
+   * Step 2 (Semantic LLM-as-a-Judge): Deep pedagogical, cognitive (Bloom), and misconception analysis with live frontier LLM.
    */
-  async loadPacksForOrg(organizationCode) {
-    let query = this.client.from("standards_frameworks").select("*, standards_org_adoptions(organization_code)").eq("status", "active");
-    const { data: frameworks, error } = await query;
-    if (error) throw new Error("loadPacksForOrg: " + error.message);
-    const visible = (frameworks ?? []).filter((f) => {
-      const own = f.organization_code && organizationCode && f.organization_code === organizationCode;
-      const global = !f.organization_code;
-      const adopted = organizationCode && (f.standards_org_adoptions ?? []).some((a) => a.organization_code === organizationCode);
-      return global || own || adopted;
+  static async auditLessonBundle(input) {
+    const { lesson, quiz, activity, slides, codeLab, modelOptions, executeLLMJudge = true } = input;
+    const structuralResult = DeterministicStructuralLinter.lintBundle({
+      lesson,
+      quiz,
+      activity,
+      slides,
+      codeLab
     });
-    if (visible.length === 0) return [];
-    const ids = visible.map((f) => f.id);
-    const [{ data: statements, error: stErr }, { data: mappings, error: mpErr }, { data: overrides, error: ovErr }] = await Promise.all([
-      this.client.from("standards_statements").select("*").in("framework_id", ids),
-      this.client.from("standards_mappings").select("*").in("framework_id", ids),
-      this.client.from("standards_mapping_overrides").select("*").in("framework_id", ids)
-    ]);
-    if (stErr) throw new Error("loadPacksForOrg statements: " + stErr.message);
-    const overridesByFw = /* @__PURE__ */ new Map();
-    for (const o of overrides ?? []) {
-      const list = overridesByFw.get(o.framework_id) ?? [];
-      list.push(o);
-      overridesByFw.set(o.framework_id, list);
-    }
-    return visible.map((f) => {
-      const stmts = (statements ?? []).filter((s) => s.framework_id === f.id).map((s) => ({
-        id: s.statement_id,
-        parentId: s.parent_statement_id ?? void 0,
-        gradeBand: [s.grade_min, s.grade_max],
-        texts: s.texts,
-        classifications: s.classifications ?? [],
-        bloomHint: s.bloom_hint ?? void 0,
-        keywords: s.keywords ?? [],
-        sourceRef: s.source_ref ?? void 0,
-        provenance: s.provenance ?? { method: "imported" }
-      }));
-      const ov = overridesByFw.get(f.id) ?? [];
-      const retired = new Set(ov.filter((o) => o.kind === "retired").map((o) => o.statement_id + "|" + o.target_ref));
-      const embedded = (mappings ?? []).filter((m) => m.framework_id === f.id).map((m) => ({
-        statementId: m.statement_id,
-        targetRef: m.target_ref,
-        kind: m.kind,
-        confidence: Number(m.confidence),
-        provenance: m.provenance ?? { method: "imported" }
-      }));
-      const overlay = ov.filter((o) => o.kind !== "retired").map((o) => ({
-        statementId: o.statement_id,
-        targetRef: o.target_ref,
-        kind: o.kind,
-        confidence: Number(o.confidence),
-        provenance: { method: "human", reviewedBy: o.created_by ?? "overlay", note: o.note ?? void 0 }
-      }));
-      const bridge = /* @__PURE__ */ new Map();
-      for (const m of embedded) bridge.set(m.statementId + "|" + m.targetRef, m);
-      for (const m of overlay) bridge.set(m.statementId + "|" + m.targetRef, m);
-      const finalMappings = [...bridge.values()].filter((m) => !retired.has(m.statementId + "|" + m.targetRef));
-      const hydrated = FrameworkPackSchema.safeParse({
-        manifest: {
-          id: f.pack_id,
-          name: f.name,
-          specVersion: f.spec_version || "1.0",
-          contentVersion: f.content_version,
-          subject: f.subject,
-          languages: f.languages,
-          gradeModel: f.grade_model,
-          provenance: f.provenance,
-          trust: f.trust
-        },
-        statements: stmts,
-        mappings: finalMappings
-      });
-      if (!hydrated.success) {
-        throw new Error('loadPacksForOrg: hydrated pack "' + f.pack_id + '" failed schema: ' + hydrated.error.issues[0]?.message);
-      }
-      return { ...hydrated.data, dbId: f.id, status: f.status, organizationCode: f.organization_code ?? null };
-    });
-  }
-};
-
-// src/workflow/workflows/milestoneWorkflow.ts
-async function generateMilestoneWorkflow(input) {
-  "use workflow";
-  const language = input.language || "vi";
-  const milestoneId = input.milestone.id || input.milestone.concept_code || "L01";
-  const slugPrefix = /^\d+$/.test(milestoneId) ? `M${milestoneId.padStart(2, "0")}` : milestoneId;
-  const milestoneSlug = `${slugPrefix}_${(input.milestone.name || "milestone").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
-  const bundleTier = input.bundleTier || "minimum";
-  const gates = resolveGateSettings(input.gateSettings);
-  const techStack = input.techStack || input.milestone.tech_keywords || ["General Technology"];
-  console.log("  \u{1F6A6} [Gate] LESSON: " + gates.LESSON + " | ACT: " + gates.ACT + " | QUIZ: " + gates.QUIZ);
-  const targetObjectives = (input.milestone.learning_objectives || []).map((lo) => ({
-    code: lo.code,
-    description: lo.description || lo.name || "",
-    bloomLevel: lo.bloom_level || "understand"
-  }));
-  const packs = input.standardsPacks ?? [];
-  const { block: standardsContext, selected: selectedStatements } = buildStandardsContext({
-    packs,
-    gradeBand: input.milestone.grade_band ?? [6, 12],
-    topicText: [input.topic, input.milestone.name, input.milestone.description, ...input.milestone.tech_keywords || []].filter(Boolean).join(" "),
-    conceptCodes: (input.milestone.concept_code || "").split(",").map((c) => c.trim()).filter(Boolean),
-    language
-  });
-  const standardStatements = {};
-  for (const s of selectedStatements) {
-    standardStatements[s.packId + ":" + s.statement.id] = Object.values(s.statement.texts)[0] || "";
-  }
-  if (selectedStatements.length > 0) {
-    console.log("  \u{1F4D0} [Standards] Grounded with " + selectedStatements.length + " verbatim statement(s) from " + new Set(selectedStatements.map((s) => s.packId)).size + " pack(s)");
-  }
-  let lesson = await generateMasterLessonStep({
-    milestone: input.milestone,
-    language,
-    topic: input.topic,
-    targetAudience: input.targetAudience,
-    standardsContext: standardsContext || void 0,
-    modelOptions: input.modelOptions
-  });
-  let auditReport;
-  const lessonGate = gateModeFor(gates, "LESSON");
-  if (lessonGate === "LLM_JUDGE") {
-    auditReport = await judgeMasterLessonStep({
-      lessonId: milestoneId,
-      lesson,
-      language,
-      targetObjectives,
-      standardStatements: Object.keys(standardStatements).length > 0 ? standardStatements : void 0,
-      modelOptions: input.modelOptions
-    });
-    if (auditReport.overallVerdict === "FAIL" || auditReport.overallVerdict === "NEEDS_REVISION") {
-      lesson = await repairMasterLessonStep({
-        milestone: input.milestone,
-        language,
-        topic: input.topic,
-        targetAudience: input.targetAudience,
-        auditReport,
-        standardsContext: standardsContext || void 0,
-        modelOptions: input.modelOptions
-      });
-    }
-  } else if (lessonGate === "HITL") {
-    const hookToken = "gate:lesson:" + milestoneId;
-    console.log("  \u23F8 [Gate] LESSON awaiting HUMAN review (HITL) \u2014 hook " + hookToken);
-    const workflowPkg = await import('workflow');
-    const createHook = workflowPkg.createHook;
-    const hook = createHook({ token: hookToken });
-    const review = await hook;
-    console.log("  \u2705 [Gate] Human verdict: " + (review.approved ? "APPROVED" : "REJECTED") + (review.feedback ? " \u2014 " + review.feedback : ""));
-    if (!review.approved) {
-      const repairReport = {
-        overallVerdict: "NEEDS_REVISION",
-        totalScore: 0,
-        languageAdherencePassed: true,
-        criteria: [],
-        actionableRepairPrompts: review.feedback ? [review.feedback] : ["S\u1EEDa theo ph\u1EA3n h\u1ED3i c\u1EE7a ng\u01B0\u1EDDi duy\u1EC7t"]
-      };
-      lesson = await repairMasterLessonStep({
-        milestone: input.milestone,
-        language,
-        topic: input.topic,
-        targetAudience: input.targetAudience,
-        auditReport: repairReport,
-        standardsContext: standardsContext || void 0,
-        modelOptions: input.modelOptions
-      });
-      const hook2 = createHook({ token: hookToken + ":v2" });
-      const review2 = await hook2;
-      console.log("  \u2705 [Gate] Human verdict (v2): " + (review2.approved ? "APPROVED" : "REJECTED"));
-      if (!review2.approved) {
-        console.log("  \u{1F6D1} [Gate] LESSON rejected twice \u2014 satellites & save BLOCKED");
-        return {
-          milestoneId,
-          milestoneSlug,
-          status: "FAILED",
-          gateBlocked: { artifactType: "LESSON", reason: "HITL_REJECTED_V2", feedback: review2.feedback },
-          artifacts: void 0
-        };
-      }
-    }
-  }
-  const [activity, selfLab, quiz, slides, handout] = await Promise.all([
-    generateActivityStep({ lesson, language, modelOptions: input.modelOptions }),
-    generateSelfLabStep({ milestone: input.milestone, language, targetTechStack: techStack, modelOptions: input.modelOptions }),
-    generateDiagnosticQuizStep({ milestone: input.milestone, language, modelOptions: input.modelOptions }),
-    generateSlidesStep({ lesson, language, modelOptions: input.modelOptions }),
-    generateHandoutStep({ lesson, language, modelOptions: input.modelOptions })
-  ]);
-  const codeLab = await generateCodeLabStep({
-    lesson,
-    activity,
-    language,
-    targetTechStack: techStack,
-    modelOptions: input.modelOptions
-  });
-  const satelliteReports = {};
-  const satelliteCandidates = [
-    { type: "ACT", id: "ACT_" + milestoneId, artifact: activity },
-    { type: "QUIZ", id: "QUIZ_" + milestoneId, artifact: quiz },
-    { type: "SLIDE", id: "SLIDE_" + milestoneId, artifact: slides },
-    { type: "HANDOUT", id: "HANDOUT_" + milestoneId, artifact: handout },
-    { type: "CODE", id: "CODE_" + milestoneId, artifact: codeLab }
-  ];
-  const toJudge = satelliteCandidates.filter((c) => c.artifact && gateModeFor(gates, c.type) === "LLM_JUDGE");
-  if (toJudge.length > 0) {
-    const reports = await Promise.all(
-      toJudge.map(
-        (c) => judgeSatelliteStep({
-          artifactType: c.type,
-          artifactId: c.id,
-          artifact: c.artifact,
-          language,
-          targetObjectives,
-          standardStatements: Object.keys(standardStatements).length > 0 ? standardStatements : void 0,
-          modelOptions: input.modelOptions
-        }).catch((err) => {
-          console.warn("  \u26A0 [Gate] satellite judge failed for " + c.type + ": " + err.message);
-          return void 0;
-        })
-      )
-    );
-    for (let i = 0; i < toJudge.length; i++) {
-      const r = reports[i];
-      if (r) satelliteReports[toJudge[i].type] = r;
-    }
-  }
-  let worksheet;
-  let teacherGuide;
-  let extension;
-  if (bundleTier === "full") {
-    [worksheet, teacherGuide, extension] = await Promise.all([
-      generateWorksheetStep({ lesson, language, modelOptions: input.modelOptions }),
-      generateTeacherGuideStep({ lesson, activity, language, modelOptions: input.modelOptions }),
-      generateExtensionStep({ lesson, activity, language, modelOptions: input.modelOptions })
-    ]);
-  }
-  let standardsCoverage;
-  if (packs.length > 0) {
-    standardsCoverage = evaluateStandardsCoverage({
-      packs,
-      objectives: (lesson.learningObjectives || []).map((lo) => ({
-        code: lo.code,
-        standardRefs: lo.standardRefs,
-        conceptRefs: lo.conceptRefs
-      })),
-      // NOTE: ActivityLab has no structured LO linkage yet — activity coverage rows are derived
-      // from LO→quiz paths inside the gate. Wire ACT.loRefs in a future schema revision.
-      activities: [],
-      quizQuestions: (quiz?.questions || []).map((q) => ({ alignedLO: q.alignedLO, alignedAO: q.alignedAO })),
-      assessmentObjectives: quiz?.assessmentObjectives?.map((ao) => ({ aoCode: ao.aoCode, alignedLO: ao.alignedLO }))
-    });
-    console.log("  \u{1F4D0} [Standards Coverage] " + standardsCoverage.summary);
-    const enforce = input.enforceStandardsCoverage ?? true;
-    if (enforce && standardsCoverage.verdict === "FAIL") {
-      console.error("  \u26D4 [Standards Coverage] HARD BLOCK \u2014 " + standardsCoverage.summary);
-      console.error(standardsCoverage.rawMarkdownReport.split("\n").filter((l) => l.startsWith("- [")).slice(0, 10).join("\n"));
-      return {
-        milestoneId,
-        milestoneSlug,
-        status: "FAILED",
-        savedResult: { workspaceDir: "", files: [] },
-        judgeReport: auditReport,
-        standardsCoverage,
-        artifacts: { lesson, activity, codeLab, selfLab, quiz, slides, handout, worksheet, teacherGuide, extension }
-      };
-    }
-  }
-  const savedResult = await saveMilestoneToWorkspaceStep({
-    jobId: input.jobId,
-    milestoneSlug,
-    lesson,
-    activity,
-    codeLab,
-    selfLab,
-    quiz,
-    slides,
-    handout,
-    baseWorkspaceDir: input.baseWorkspaceDir
-  });
-  return {
-    milestoneId,
-    milestoneSlug,
-    status: "SUCCESS",
-    savedResult,
-    judgeReport: auditReport,
-    satelliteJudgeReports: Object.keys(satelliteReports).length > 0 ? satelliteReports : void 0,
-    gatesResolved: gates,
-    standardsCoverage,
-    artifacts: {
-      lesson,
-      activity,
-      codeLab,
-      selfLab,
-      quiz,
-      slides,
-      handout,
-      worksheet,
-      teacherGuide,
-      extension
-    }
-  };
-}
-async function generateRoadmapWorkflow(input) {
-  "use workflow";
-  const jobId = input.jobId || `job_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
-  const language = input.language || input.roadmap.target_language || "vi";
-  const topic = input.roadmap.topic || input.roadmap.goal || "General Curriculum";
-  const courseTitle = input.roadmap.title || `Curriculum: ${topic}`;
-  const batchSize = input.batchSize || 2;
-  const milestones = input.roadmap.milestones || [];
-  const workspaceManager = new LocalWorkspaceManager(input.baseWorkspaceDir);
-  const workspaceDir = await workspaceManager.initJobWorkspace(jobId, {
-    courseTitle,
-    topic,
-    language,
-    totalMilestones: milestones.length
-  });
-  const milestoneOutcomes = [];
-  for (let i = 0; i < milestones.length; i += batchSize) {
-    const batch = milestones.slice(i, i + batchSize);
-    const batchSettled = await Promise.allSettled(
-      batch.map(
-        (milestone) => generateMilestoneWorkflow({
-          jobId,
-          milestone,
-          language,
-          topic,
-          targetAudience: input.roadmap.target_audience,
-          techStack: input.roadmap.tech_stack || milestone.tech_keywords,
-          bundleTier: input.bundleTier,
-          gateSettings: input.gateSettings,
-          baseWorkspaceDir: input.baseWorkspaceDir,
-          modelOptions: input.modelOptions
-        })
-      )
-    );
-    for (const [idx, outcome] of batchSettled.entries()) {
-      const targetMilestone = batch[idx];
-      const mId = targetMilestone.id || targetMilestone.concept_code || `M${i + idx + 1}`;
-      if (outcome.status === "fulfilled") {
-        milestoneOutcomes.push({
-          milestoneId: mId,
-          status: "FULFILLED",
-          result: outcome.value
+    const allFindings = [...structuralResult.findings];
+    const strengths = [...structuralResult.strengths];
+    let semanticScore = null;
+    let semanticVerdict = "PASS";
+    if (executeLLMJudge) {
+      try {
+        const judgeReport = await auditCurriculumQualityFlow({
+          targetArtifactType: "LESSON_BUNDLE",
+          lessonId: lesson.lessonId,
+          expectedLanguage: lesson.language,
+          targetObjectives: (lesson.learningObjectives || []).map((lo) => ({
+            code: lo.code,
+            description: lo.description,
+            bloomLevel: lo.bloomLevel
+          })),
+          generatedContentJson: JSON.stringify({ lesson, quiz, activity, slides, codeLab }),
+          modelOptions
         });
-      } else {
-        milestoneOutcomes.push({
-          milestoneId: mId,
-          status: "REJECTED",
-          error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
+        semanticScore = judgeReport.totalScore;
+        semanticVerdict = judgeReport.overallVerdict;
+        for (const criterion of judgeReport.criteria) {
+          if (!criterion.passed) {
+            allFindings.push({
+              id: `llm_judge_${criterion.name.toLowerCase().replace(/\s+/g, "_")}`,
+              dimension: "CONSTRUCTIVE_ALIGNMENT",
+              severity: criterion.score < 50 ? "CRITICAL" : "MAJOR",
+              title: `LLM-as-Judge Finding: ${criterion.name}`,
+              description: criterion.feedback,
+              remediationAdvice: judgeReport.actionableRepairPrompts.join("; ") || "Refine prompt context."
+            });
+          } else {
+            strengths.push(`[LLM-Judge] ${criterion.name}: ${criterion.feedback}`);
+          }
+        }
+      } catch (err) {
+        semanticScore = null;
+        semanticVerdict = "FAIL";
+        allFindings.push({
+          id: "llm_judge_connection_error",
+          dimension: "CONSTRUCTIVE_ALIGNMENT",
+          severity: "MINOR",
+          title: "LLM-as-Judge Skipped / Fallback",
+          description: `Semantic inference error: ${err.message || String(err)}`,
+          remediationAdvice: "Check API credentials for LLM-as-Judge."
         });
       }
     }
-    if (i + batchSize < milestones.length) {
-      await workflow.sleep("2s");
+    const criticalCount = allFindings.filter((f) => f.severity === "CRITICAL").length;
+    const overallScore = executeLLMJudge && semanticScore !== null ? Math.round(structuralResult.structuralScore * 0.4 + semanticScore * 0.6) : structuralResult.structuralScore;
+    const passed = structuralResult.passed && criticalCount === 0 && (executeLLMJudge ? semanticVerdict === "PASS" : true);
+    let verdict = "REJECTED";
+    if (overallScore >= 90 && criticalCount === 0) {
+      verdict = "EXEMPLARY";
+    } else if (overallScore >= 75 && criticalCount === 0) {
+      verdict = "ACADEMICALLY_SOUND";
+    } else if (overallScore >= 60) {
+      verdict = "NEEDS_PEDAGOGICAL_REFINEMENT";
     }
+    const summary = passed ? `\u2705 Lesson Bundle "${lesson.title}" (${lesson.lessonId}) passes academic & structural verification with score ${overallScore}/100 (${verdict}).` : `\u26A0\uFE0F Lesson Bundle "${lesson.title}" requires revision (${overallScore}/100 - ${verdict}). Found ${allFindings.length} finding(s) with ${criticalCount} critical blocker(s).`;
+    const actionablePromptGuidance = allFindings.map(
+      (f, idx) => `[${f.dimension}] ${idx + 1}. ${f.title}: ${f.remediationAdvice}`
+    );
+    const computeDimScore = (dimFindings2) => {
+      const hasCritical = dimFindings2.some((f) => f.severity === "CRITICAL");
+      const majorCount = dimFindings2.filter((f) => f.severity === "MAJOR").length;
+      const minorCount = dimFindings2.filter((f) => f.severity === "MINOR").length;
+      let dimScore = 100 - (hasCritical ? 40 : 0) - majorCount * 15 - minorCount * 5;
+      dimScore = Math.max(0, Math.min(100, dimScore));
+      return { score: dimScore, passed: dimScore >= 75 && !hasCritical };
+    };
+    const dimFindings = {
+      constructiveAlignment: allFindings.filter((f) => f.dimension === "CONSTRUCTIVE_ALIGNMENT"),
+      bloomProgression: allFindings.filter((f) => f.dimension === "BLOOM_PROGRESSION"),
+      fiveEFidelity: allFindings.filter((f) => f.dimension === "5E_INSTRUCTIONAL_FIDELITY"),
+      misconceptionRigor: allFindings.filter((f) => f.dimension === "MISCONCEPTION_RIGOR"),
+      technicalAuthenticity: allFindings.filter((f) => f.dimension === "TECHNICAL_AUTHENTICITY")
+    };
+    const dimScores = Object.fromEntries(
+      Object.entries(dimFindings).map(([k, v]) => [k, computeDimScore(v)])
+    );
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      targetId: lesson.lessonId,
+      targetType: "BUNDLE",
+      overallScore,
+      passed,
+      verdict,
+      summary,
+      dimensionScores: {
+        constructiveAlignment: {
+          score: dimScores.constructiveAlignment.score,
+          weight: 0.2,
+          passed: dimScores.constructiveAlignment.passed,
+          strengths: dimScores.constructiveAlignment.passed ? ["Constructive alignment verified."] : [],
+          findings: dimFindings.constructiveAlignment
+        },
+        bloomProgression: {
+          score: dimScores.bloomProgression.score,
+          weight: 0.2,
+          passed: dimScores.bloomProgression.passed,
+          strengths: dimScores.bloomProgression.passed ? ["Bloom taxonomy progression verified."] : [],
+          findings: dimFindings.bloomProgression
+        },
+        fiveEFidelity: {
+          score: dimScores.fiveEFidelity.score,
+          weight: 0.15,
+          passed: dimScores.fiveEFidelity.passed,
+          strengths: dimScores.fiveEFidelity.passed ? ["5E instructional fidelity verified."] : [],
+          findings: dimFindings.fiveEFidelity
+        },
+        misconceptionRigor: {
+          score: dimScores.misconceptionRigor.score,
+          weight: 0.2,
+          passed: dimScores.misconceptionRigor.passed,
+          strengths: dimScores.misconceptionRigor.passed ? ["Misconception rigor verified."] : [],
+          findings: dimFindings.misconceptionRigor
+        },
+        technicalAuthenticity: {
+          score: dimScores.technicalAuthenticity.score,
+          weight: 0.15,
+          passed: dimScores.technicalAuthenticity.passed,
+          strengths: dimScores.technicalAuthenticity.passed ? ["Technical authenticity verified."] : [],
+          findings: dimFindings.technicalAuthenticity
+        },
+        crossArtifactZeroDrift: {
+          score: structuralResult.structuralScore,
+          weight: 0.1,
+          passed: structuralResult.passed,
+          strengths: structuralResult.passed ? ["Cross-artifact zero drift verified."] : [],
+          findings: allFindings.filter((f) => f.dimension === "CROSS_ARTIFACT_ZERO_DRIFT")
+        }
+      },
+      criticalFindingsCount: criticalCount,
+      allFindings,
+      actionablePromptGuidance
+    };
   }
-  const successfulMilestones = milestoneOutcomes.filter((m) => m.status === "FULFILLED").length;
-  const failedMilestones = milestoneOutcomes.filter((m) => m.status === "REJECTED").length;
-  let gitPublishResult = void 0;
-  let supabasePublishResult = void 0;
-  if (input.gitPublishOptions) {
-    gitPublishResult = await publishToGitStep({
-      jobId,
-      localJobDir: workspaceDir,
-      ...input.gitPublishOptions
-    });
-  }
-  if (input.supabasePublishOptions) {
-    supabasePublishResult = await publishToSupabaseStep({
-      jobId,
-      courseTitle,
-      topic,
-      language,
-      milestones: milestoneOutcomes.filter((m) => m.status === "FULFILLED" && m.result).map((m) => ({
-        milestoneId: m.milestoneId,
-        milestoneName: m.result.savedResult.milestoneSlug,
-        lessonSlug: m.result.savedResult.milestoneSlug
-      })),
-      ...input.supabasePublishOptions
-    });
-  }
-  return {
-    jobId,
-    courseTitle,
-    topic,
-    language,
-    totalMilestones: milestones.length,
-    successfulMilestones,
-    failedMilestones,
-    results: milestoneOutcomes,
-    gitPublishResult,
-    supabasePublishResult,
-    workspaceDir
-  };
-}
-
-// src/workflow/workflows/singleArtifactWorkflow.ts
-async function executeSingleArtifactStep(request) {
-  "use step";
-  const t0 = Date.now();
-  console.log(`  \u23F3 [Step: Single Artifact] Generating ${request.artifactType.toUpperCase()} for "${request.topic.slice(0, 35)}"...`);
-  const res = await withRateLimitBackoff({
-    stepName: `generate-single-artifact-${request.artifactType}-${(request.topic || "topic").slice(0, 20)}`,
-    fn: async () => generateSingleArtifact(request)
-  });
-  console.log(`  \u2705 [Step: Single Artifact] Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (File: "${res.filename}")`);
-  return res;
-}
-async function generateSingleArtifactWorkflow(request) {
-  "use workflow";
-  return executeSingleArtifactStep(request);
-}
-
-// src/index.ts
-init_errors();
+};
 
-// src/evaluators/deterministicStructuralLinter.ts
-var DeterministicStructuralLinter = class {
-  /**
-   * Validates structural invariants across a complete lesson bundle.
-   */
-  static lintBundle(input) {
-    const { lesson, quiz, activity, slides, codeLab } = input;
+// src/evaluators/bloomTaxonomyEvaluator.ts
+var BLOOM_ACTION_VERBS = {
+  remember: [
+    "list",
+    "define",
+    "recall",
+    "state",
+    "name",
+    "identify",
+    "label",
+    "recognize",
+    "li\u1EC7t k\xEA",
+    "\u0111\u1ECBnh ngh\u0129a",
+    "g\u1ECDi t\xEAn",
+    "nh\u1EADn di\u1EC7n",
+    "ch\u1EC9 ra",
+    "nh\u1EAFc l\u1EA1i",
+    "ghi nh\u1EDB"
+  ],
+  understand: [
+    "explain",
+    "describe",
+    "summarize",
+    "classify",
+    "interpret",
+    "predict",
+    "trace",
+    "paraphrase",
+    "gi\u1EA3i th\xEDch",
+    "m\xF4 t\u1EA3",
+    "t\xF3m t\u1EAFt",
+    "ph\xE2n lo\u1EA1i",
+    "di\u1EC5n gi\u1EA3i",
+    "d\u1EF1 \u0111o\xE1n",
+    "l\u1EA7n theo",
+    "hi\u1EC3u"
+  ],
+  apply: [
+    "implement",
+    "execute",
+    "calculate",
+    "solve",
+    "construct",
+    "debug",
+    "modify",
+    "build",
+    "\xE1p d\u1EE5ng",
+    "th\u1EF1c thi",
+    "t\xEDnh to\xE1n",
+    "gi\u1EA3i quy\u1EBFt",
+    "x\xE2y d\u1EF1ng",
+    "s\u1EEDa l\u1ED7i",
+    "l\u1EAFp \u0111\u1EB7t",
+    "vi\u1EBFt m\xE3",
+    "l\u1EADp tr\xECnh"
+  ],
+  analyze: [
+    "compare",
+    "contrast",
+    "decompose",
+    "differentiate",
+    "troubleshoot",
+    "diagnose",
+    "deconstruct",
+    "so s\xE1nh",
+    "\u0111\u1ED1i chi\u1EBFu",
+    "ph\xE2n t\xEDch",
+    "ph\xE2n r\xE3",
+    "ch\u1EA9n \u0111o\xE1n",
+    "t\xECm nguy\xEAn nh\xE2n g\u1ED1c",
+    "b\xF3c t\xE1ch"
+  ],
+  evaluate: [
+    "justify",
+    "critique",
+    "assess",
+    "defend",
+    "argue",
+    "benchmark",
+    "prioritize",
+    "\u0111\xE1nh gi\xE1",
+    "bi\u1EC7n minh",
+    "ph\xEA ph\xE1n",
+    "th\u1EA9m \u0111\u1ECBnh",
+    "b\u1EA3o v\u1EC7 quan \u0111i\u1EC3m",
+    "l\u1EF1a ch\u1ECDn t\u1ED1i \u01B0u"
+  ],
+  create: [
+    "design",
+    "synthesize",
+    "architect",
+    "formulate",
+    "invent",
+    "devise",
+    "author",
+    "thi\u1EBFt k\u1EBF",
+    "t\u1ED5ng h\u1EE3p",
+    "s\xE1ng t\u1EA1o",
+    "ki\u1EBFn tr\xFAc",
+    "ph\xE1t minh",
+    "ho\xE0n thi\u1EC7n \u0111\u1ED3 \xE1n"
+  ]
+};
+var RECALL_PATTERNS = [
+  /^(?:chức năng chính của|định nghĩa của|cú pháp của|lệnh nào là|what is the definition of|which keyword|what does .* stand for)/i,
+  /(?:là gì\?|được gọi là gì\?|có ý nghĩa gì\?)/i
+];
+var BloomTaxonomyEvaluator = class {
+  /**
+   * Audits a LessonPlan for Bloom taxonomy fidelity and cognitive scaffolding.
+   */
+  static evaluateLesson(lesson) {
     const findings = [];
     const strengths = [];
     let score = 100;
-    const baseLessonId = lesson.lessonId;
-    const baseLanguage = lesson.language;
-    if (!lesson.title || lesson.title.trim().length === 0) {
-      score -= 20;
-      findings.push({
-        id: "struct_missing_lesson_title",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "CRITICAL",
-        title: "Missing Lesson Title",
-        description: "Lesson plan has an empty or whitespace title.",
-        remediationAdvice: "Provide a non-empty lesson title."
-      });
+    const los = lesson.learningObjectives || [];
+    if (los.length === 0) {
+      return {
+        score: 0,
+        weight: 0.2,
+        passed: false,
+        strengths: [],
+        findings: [
+          {
+            id: "bloom_missing_los",
+            dimension: "BLOOM_PROGRESSION",
+            severity: "CRITICAL",
+            title: "Missing Learning Objectives",
+            description: "The lesson plan contains zero declared Learning Objectives.",
+            remediationAdvice: "Add 2-4 clearly articulated LOs with Bloom levels and observable success criteria."
+          }
+        ]
+      };
     }
-    if (!lesson.learningObjectives || lesson.learningObjectives.length === 0) {
-      score -= 25;
-      findings.push({
-        id: "struct_empty_learning_objectives",
-        dimension: "CONSTRUCTIVE_ALIGNMENT",
-        severity: "CRITICAL",
-        title: "Empty Learning Objectives Array",
-        description: "Lesson plan contains 0 learning objectives.",
-        remediationAdvice: "Declare at least 2 structured Learning Objectives in the schema."
-      });
+    for (const lo of los) {
+      const declaredLevel = (lo.bloomLevel || "").toLowerCase();
+      const text = `${lo.name || ""} ${lo.description || ""} ${lo.successCriteria || ""}`.toLowerCase();
+      const isRecallPattern = RECALL_PATTERNS.some((p) => p.test(text));
+      if (isRecallPattern && (declaredLevel === "apply" || declaredLevel === "analyze" || declaredLevel === "evaluate")) {
+        score -= 15;
+        findings.push({
+          id: `bloom_inflation_${lo.code}`,
+          dimension: "BLOOM_PROGRESSION",
+          severity: "MAJOR",
+          title: `Bloom Level Inflation in LO "${lo.code}"`,
+          description: `LO is tagged as "${lo.bloomLevel}" but its phrasing reflects low-level Recall ("${lo.description}").`,
+          remediationAdvice: `Rewrite the objective using authentic "${declaredLevel}" active verbs (e.g. build, debug, compare, diagnose) with an explicit application context.`,
+          affectedElement: lo.code
+        });
+      }
+      if (!lo.successCriteria || lo.successCriteria.trim().length < 15) {
+        score -= 10;
+        findings.push({
+          id: `bloom_unmeasurable_criteria_${lo.code}`,
+          dimension: "BLOOM_PROGRESSION",
+          severity: "MINOR",
+          title: `Vague Success Criteria in LO "${lo.code}"`,
+          description: `Success criteria "${lo.successCriteria || ""}" is too brief to provide objective student evidence.`,
+          remediationAdvice: 'Specify concrete, observable evidence (e.g. "LED blinks with 1s period without circuit shorting").',
+          affectedElement: lo.code
+        });
+      } else {
+        strengths.push(`LO "${lo.code}" defines concrete observable student evidence.`);
+      }
     }
-    if (!lesson.sections || lesson.sections.length === 0) {
-      score -= 25;
+    const diff = lesson.differentiation;
+    if (diff) {
+      if (!diff.bronzeTier || !diff.silverTier || !diff.goldTier) {
+        score -= 15;
+        findings.push({
+          id: "bloom_incomplete_differentiation",
+          dimension: "BLOOM_PROGRESSION",
+          severity: "MAJOR",
+          title: "Incomplete 3-Tier Scaffolding",
+          description: "Differentiation must provide distinct Bronze (Foundation), Silver (Application), and Gold (Extension) challenges.",
+          remediationAdvice: "Define all 3 tiers with increasing cognitive demands (Remember/Understand -> Apply -> Analyze/Create)."
+        });
+      } else {
+        strengths.push("Complete 3-tier scaffolding (Bronze -> Silver -> Gold) present in Lesson Plan.");
+      }
+    } else {
+      score -= 20;
       findings.push({
-        id: "struct_empty_lesson_sections",
-        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        id: "bloom_missing_differentiation",
+        dimension: "BLOOM_PROGRESSION",
         severity: "CRITICAL",
-        title: "Empty Lesson Sections Array",
-        description: "Lesson plan contains no instructional sections.",
-        remediationAdvice: "Provide structured lesson flow sections."
+        title: "Missing Differentiation Scaffolding",
+        description: "Lesson plan lacks differentiation tiers.",
+        remediationAdvice: "Provide tiered practice instructions for varied learner paces."
       });
     }
-    if (quiz && quiz.quizId !== baseLessonId && !quiz.quizId.includes(baseLessonId)) {
-      score -= 15;
+    score = Math.max(0, Math.min(100, score));
+    return {
+      score,
+      weight: 0.2,
+      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
+      strengths,
+      findings
+    };
+  }
+  /**
+   * Audits a Diagnostic Quiz for true cognitive depth matching declared Bloom levels.
+   */
+  static evaluateQuiz(quiz) {
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    const questions = quiz.questions || [];
+    if (questions.length < 3) {
+      score -= 30;
       findings.push({
-        id: "struct_quiz_id_mismatch",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        id: "bloom_quiz_too_short",
+        dimension: "BLOOM_PROGRESSION",
         severity: "MAJOR",
-        title: "Quiz ID Contract Mismatch",
-        description: `Quiz ID "${quiz.quizId}" does not match Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Sync Quiz quizId to "${baseLessonId}".`,
-        affectedElement: quiz.quizId
+        title: "Insufficient Question Pool",
+        description: `Quiz only contains ${questions.length} questions. Minimum diagnostic threshold is 3 questions.`,
+        remediationAdvice: "Generate at least 3-5 diagnostic questions covering foundational through analytical depth."
       });
     }
-    if (activity && activity.lessonId !== baseLessonId) {
-      score -= 15;
-      findings.push({
-        id: "struct_act_id_mismatch",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "MAJOR",
-        title: "Activity Lesson ID Contract Mismatch",
-        description: `Activity lessonId "${activity.lessonId}" does not match Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Sync Activity lessonId to "${baseLessonId}".`,
-        affectedElement: activity.lessonId
-      });
+    let understandCount = 0;
+    let applyCount = 0;
+    let analyzeCount = 0;
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      const qId = q.id || `Q${i + 1}`;
+      const declaredBloom = (q.bloomLevel || "").toLowerCase();
+      const stem = q.scenarioOrStem || "";
+      if (declaredBloom === "understand") understandCount++;
+      if (declaredBloom === "apply") applyCount++;
+      if (declaredBloom === "analyze" || declaredBloom === "evaluate") analyzeCount++;
+      const isRecall = RECALL_PATTERNS.some((p) => p.test(stem));
+      if (isRecall && (declaredBloom === "apply" || declaredBloom === "analyze")) {
+        score -= 15;
+        findings.push({
+          id: `bloom_quiz_misclassification_${qId}`,
+          dimension: "BLOOM_PROGRESSION",
+          severity: "MAJOR",
+          title: `Cognitive Level Misclassification in ${qId}`,
+          description: `Question stem "${stem.substring(0, 60)}..." is pure Recall/Definition, but is tagged as "${q.bloomLevel}".`,
+          remediationAdvice: 'Either re-tag as "understand" or transform the stem into an authentic problem-solving scenario requiring code debugging or design decision.',
+          affectedElement: qId
+        });
+      }
+      if ((declaredBloom === "apply" || declaredBloom === "analyze") && !q.codeSnippet && !stem.includes("```") && !stem.includes("m\u1EA1ch")) {
+        score -= 10;
+        findings.push({
+          id: `bloom_quiz_missing_code_context_${qId}`,
+          dimension: "BLOOM_PROGRESSION",
+          severity: "MINOR",
+          title: `Missing Practical Context in High-Bloom Question ${qId}`,
+          description: `Question ${qId} tagged as "${q.bloomLevel}" lacks concrete code or circuit context to evaluate hands-on execution.`,
+          remediationAdvice: "Include an annotated code snippet or circuit state for students to trace, debug, or evaluate.",
+          affectedElement: qId
+        });
+      }
     }
-    if (slides && slides.lessonId !== baseLessonId) {
+    if (questions.length > 0 && (understandCount > 0 || applyCount > 0)) {
+      strengths.push(`Quiz features multi-level cognitive questions (Understand: ${understandCount}, Apply: ${applyCount}, Analyze: ${analyzeCount}).`);
+    }
+    score = Math.max(0, Math.min(100, score));
+    return {
+      score,
+      weight: 0.2,
+      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
+      strengths,
+      findings
+    };
+  }
+};
+
+// src/evaluators/crossArtifactDriftEvaluator.ts
+var CrossArtifactDriftEvaluator = class {
+  /**
+   * Audits consistency, metadata synchronization, and zero-drift across all artifacts in a lesson bundle.
+   */
+  static evaluateBundle(lesson, quiz, activity, slides) {
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    const baseLessonId = lesson.lessonId;
+    const baseLanguage = lesson.language;
+    if (quiz && quiz.quizId && quiz.quizId !== baseLessonId && !quiz.quizId.includes(baseLessonId)) {
       score -= 15;
       findings.push({
-        id: "struct_slides_id_mismatch",
+        id: "drift_quiz_id_mismatch",
         dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
         severity: "MAJOR",
-        title: "Slide Deck Lesson ID Contract Mismatch",
-        description: `Slide deck lessonId "${slides.lessonId}" does not match Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Sync Slide deck lessonId to "${baseLessonId}".`,
+        title: "Quiz ID Mismatch with Master Lesson",
+        description: `Quiz ID "${quiz.quizId}" diverges from master Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Align Quiz ID to "${baseLessonId}".`,
+        affectedElement: quiz.quizId
+      });
+    }
+    if (activity && activity.lessonId && activity.lessonId !== baseLessonId) {
+      score -= 15;
+      findings.push({
+        id: "drift_act_id_mismatch",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MAJOR",
+        title: "Activity Lesson ID Mismatch",
+        description: `Activity lessonId "${activity.lessonId}" diverges from master Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Align Activity lessonId to "${baseLessonId}".`,
+        affectedElement: activity.lessonId
+      });
+    }
+    if (slides && slides.lessonId && slides.lessonId !== baseLessonId) {
+      score -= 15;
+      findings.push({
+        id: "drift_slides_id_mismatch",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MAJOR",
+        title: "Slide Deck Lesson ID Mismatch",
+        description: `Slide deck lessonId "${slides.lessonId}" diverges from master Lesson ID "${baseLessonId}".`,
+        remediationAdvice: `Align Slide deck lessonId to "${baseLessonId}".`,
         affectedElement: slides.lessonId
       });
     }
@@ -15616,589 +15317,377 @@ var DeterministicStructuralLinter = class {
       if (sat.lang && sat.lang.toLowerCase() !== baseLanguage.toLowerCase()) {
         score -= 25;
         findings.push({
-          id: `struct_language_mismatch_${sat.type}`,
+          id: `drift_language_mismatch_${sat.type}`,
           dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
           severity: "CRITICAL",
-          title: `Language Policy Inconsistency in ${sat.type}`,
+          title: `Language Contamination in ${sat.type}`,
           description: `Master Lesson is in "${baseLanguage}" but ${sat.type} is declared in "${sat.lang}".`,
-          remediationAdvice: `Set ${sat.type} language to "${baseLanguage}".`
+          remediationAdvice: `Regenerate ${sat.type} strictly in "${baseLanguage}".`
         });
       }
     }
-    if (quiz && quiz.questions) {
-      for (let i = 0; i < quiz.questions.length; i++) {
-        const q = quiz.questions[i];
-        const qId = q.id || `Q${i + 1}`;
-        const options = q.options || [];
-        if (options.length < 4) {
-          score -= 10;
-          findings.push({
-            id: `struct_quiz_option_count_${qId}`,
-            dimension: "MISCONCEPTION_RIGOR",
-            severity: "MAJOR",
-            title: `Structural Option Count Error in ${qId}`,
-            description: `Question ${qId} has ${options.length} options (standard schema requires 4).`,
-            remediationAdvice: "Ensure each question has 4 options (A, B, C, D).",
-            affectedElement: qId
-          });
-        }
-        const correctCount = options.filter((o) => o.isCorrect).length;
-        if (correctCount !== 1) {
+    const sections = lesson.sections || [];
+    const totalSectionMins = sections.reduce((sum, s) => sum + (s.durationMinutes || 0), 0);
+    if (totalSectionMins > 0 && (totalSectionMins < 40 || totalSectionMins > 180)) {
+      score -= 10;
+      findings.push({
+        id: "drift_unrealistic_lesson_duration",
+        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+        severity: "MINOR",
+        title: `Unrealistic Lesson Flow Total Duration (${totalSectionMins} mins)`,
+        description: `Sum of 5E section durations is ${totalSectionMins} minutes. Standard K-12/College lessons span 45-120 minutes.`,
+        remediationAdvice: "Adjust individual section timings so total duration matches standard classroom blocks (e.g. 60m or 90m)."
+      });
+    } else if (totalSectionMins > 0) {
+      strengths.push(`Lesson section timings sum up to a realistic classroom block (${totalSectionMins} mins).`);
+    }
+    if (score >= 90) {
+      strengths.push("Zero drift verified: IDs, language policies, and pedagogical contracts are strictly aligned across all artifacts.");
+    }
+    score = Math.max(0, Math.min(100, score));
+    return {
+      score,
+      weight: 0.1,
+      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
+      strengths,
+      findings
+    };
+  }
+};
+
+// src/evaluators/constructiveAlignmentEvaluator.ts
+var ConstructiveAlignmentEvaluator = class {
+  /**
+   * Evaluates constructive alignment within a LessonPlan and across its satellite artifacts.
+   */
+  static evaluateLesson(lesson, quiz, activity) {
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    const los = lesson.learningObjectives || [];
+    const sections = lesson.sections || [];
+    const exitTicket = lesson.exitTicket;
+    if (los.length === 0) {
+      return {
+        score: 0,
+        weight: 0.2,
+        passed: false,
+        strengths: [],
+        findings: [
+          {
+            id: "align_no_los",
+            dimension: "CONSTRUCTIVE_ALIGNMENT",
+            severity: "CRITICAL",
+            title: "No Learning Objectives Defined",
+            description: "Constructive alignment cannot be established without baseline LOs.",
+            remediationAdvice: "Define at least 2 measurable Learning Objectives."
+          }
+        ]
+      };
+    }
+    const combinedSectionText = sections.map((s) => `${s.title} ${s.teacherActions} ${s.studentActions} ${(s.analogies || []).join(" ")}`).join(" ").toLowerCase();
+    for (const lo of los) {
+      const loKeywords = (lo.name || lo.description || "").toLowerCase().split(/\s+/).filter((w) => w.length > 4);
+      const hasCoverage = loKeywords.some((k) => combinedSectionText.includes(k));
+      if (!hasCoverage && loKeywords.length > 0) {
+        score -= 15;
+        findings.push({
+          id: `align_uncovered_lo_${lo.code}`,
+          dimension: "CONSTRUCTIVE_ALIGNMENT",
+          severity: "MAJOR",
+          title: `Untaught Objective in Lesson Flow: "${lo.code}"`,
+          description: `The LO "${lo.name || lo.code}" is declared in the objectives table but receives minimal coverage in the 5E lesson sections.`,
+          remediationAdvice: `Add explicit Teacher Moves and Student Actions in the Explore/Explain sections addressing "${lo.name}".`,
+          affectedElement: lo.code
+        });
+      }
+    }
+    if (!exitTicket || !exitTicket.questionStem || exitTicket.questionStem.trim().length < 15) {
+      score -= 15;
+      findings.push({
+        id: "align_missing_exit_ticket",
+        dimension: "CONSTRUCTIVE_ALIGNMENT",
+        severity: "MAJOR",
+        title: "Missing or Shallow Exit Ticket",
+        description: "The lesson ends without a rigorous formative Exit Ticket to measure LO attainment before class dismissal.",
+        remediationAdvice: "Include an Exit Ticket question matching the primary LO + a metacognitive reflection prompt."
+      });
+    } else {
+      strengths.push("Formative Exit Ticket is properly anchored at the conclusion of the lesson.");
+    }
+    if (quiz) {
+      const quizQuestions = quiz.questions || [];
+      if (quizQuestions.length > 0) {
+        const quizText = quizQuestions.map((q) => `${q.scenarioOrStem} ${(q.options || []).map((o) => o.text).join(" ")}`).join(" ").toLowerCase();
+        const lessonTopicKeywords = (lesson.topic || lesson.title || "").toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+        const hasTopicMatch = lessonTopicKeywords.some((k) => quizText.includes(k));
+        if (!hasTopicMatch && lessonTopicKeywords.length > 0) {
           score -= 20;
           findings.push({
-            id: `struct_quiz_key_count_${qId}`,
-            dimension: "MISCONCEPTION_RIGOR",
+            id: "align_quiz_topic_divergence",
+            dimension: "CONSTRUCTIVE_ALIGNMENT",
             severity: "CRITICAL",
-            title: `Key Assignment Error in ${qId}`,
-            description: `Question ${qId} has ${correctCount} correct options (must be exactly 1).`,
-            remediationAdvice: "Set `isCorrect: true` on exactly 1 option.",
-            affectedElement: qId
+            title: "Quiz Topic Divergence from Lesson",
+            description: `Quiz questions do not reflect the main topic "${lesson.topic}" of the master lesson.`,
+            remediationAdvice: "Re-align quiz questions strictly to the core concepts taught in the lesson."
           });
+        } else {
+          strengths.push("Diagnostic Quiz questions tightly reflect the lesson topic and concepts.");
         }
       }
     }
-    if (activity?.materialsBOM?.hardware && activity.materialsBOM.hardware.length > 0) {
-      const hwText = activity.materialsBOM.hardware.join(" ").toLowerCase();
-      const hasLED = hwText.includes("led");
-      const hasResistor = hwText.includes("\u0111i\u1EC7n tr\u1EDF") || hwText.includes("resistor") || hwText.includes("220") || hwText.includes("330") || hwText.includes("1k");
-      if (hasLED && !hasResistor) {
-        score -= 20;
+    if (activity) {
+      const actObj = (activity.objective || "").toLowerCase();
+      const lessonTitleLower = (lesson.title || "").toLowerCase();
+      const hasActAlignment = los.some((lo) => actObj.includes((lo.name || "").toLowerCase()) || actObj.includes((lo.description || "").toLowerCase())) || actObj.includes(lessonTitleLower) || lessonTitleLower.split(/\s+/).some((w) => w.length > 4 && actObj.includes(w));
+      if (!hasActAlignment && activity.objective) {
+        score -= 15;
         findings.push({
-          id: "struct_hardware_unsafe_led_no_resistor",
-          dimension: "TECHNICAL_AUTHENTICITY",
-          severity: "CRITICAL",
-          title: "Unsafe Circuit BOM: LED without Current-Limiting Resistor",
-          description: "Hardware BOM includes LED without a 220\u03A9-1k\u03A9 resistor, causing circuit overload.",
-          remediationAdvice: "Add a 220\u03A9 current-limiting resistor to the hardware materials list."
+          id: "align_act_objective_divergence",
+          dimension: "CONSTRUCTIVE_ALIGNMENT",
+          severity: "MAJOR",
+          title: "Activity Objective Disconnected from Lesson Plan",
+          description: `Activity objective "${activity.objective}" does not directly support the lesson LOs.`,
+          remediationAdvice: "Ensure the Activity hands-on lab operationalizes the exact LOs specified in the Master Lesson."
         });
+      } else {
+        strengths.push("Activity lab objective directly operationalizes master lesson learning goals.");
       }
     }
     score = Math.max(0, Math.min(100, score));
-    const passed = score >= 80 && !findings.some((f) => f.severity === "CRITICAL");
-    if (passed) {
-      strengths.push("Deterministic structure, ID contracts, and schema invariants strictly verified.");
-    }
     return {
-      passed,
-      structuralScore: score,
-      findings,
-      strengths
+      score,
+      weight: 0.2,
+      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
+      strengths,
+      findings
     };
   }
 };
 
-// src/evaluators/academicAuditor.ts
-var AcademicAuditor = class {
+// src/evaluators/fiveEInstructionalEvaluator.ts
+var FIVE_E_STAGES = [
+  { key: "engage", label: "Engage (Kh\u1EDFi \u0111\u1ED9ng / M\xF3c neo)", regex: /(?:engage|khởi động|hook|mở đầu|anchor)/i },
+  { key: "explore", label: "Explore (Kh\xE1m ph\xE1 / Tr\u1EA3i nghi\u1EC7m)", regex: /(?:explore|khám phá|trải nghiệm|thử nghiệm)/i },
+  { key: "explain", label: "Explain (Gi\u1EA3i th\xEDch / H\xECnh th\xE0nh ki\u1EBFn th\u1EE9c)", regex: /(?:explain|giải thích|khái niệm|kiến thức cốt lõi)/i },
+  { key: "elaborate", label: "Elaborate (V\u1EADn d\u1EE5ng / M\u1EDF r\u1ED9ng)", regex: /(?:elaborate|vận dụng|luyện tập|thực hành|áp dụng)/i },
+  { key: "evaluate", label: "Evaluate (\u0110\xE1nh gi\xE1 / T\u1ED5ng k\u1EBFt)", regex: /(?:evaluate|đánh giá|tổng kết|wrap-up|exit ticket)/i }
+];
+var FiveEInstructionalEvaluator = class {
   /**
-   * Evaluates a complete lesson bundle.
-   * Step 1 (Deterministic): Fast structural, contract, schema, and safety linting.
-   * Step 2 (Semantic LLM-as-a-Judge): Deep pedagogical, cognitive (Bloom), and misconception analysis with live frontier LLM.
+   * Evaluates the pedagogical structure of a Lesson Plan against the 5E Inquiry Model.
    */
-  static async auditLessonBundle(input) {
-    const { lesson, quiz, activity, slides, codeLab, modelOptions, executeLLMJudge = true } = input;
-    const structuralResult = DeterministicStructuralLinter.lintBundle({
-      lesson,
-      quiz,
-      activity,
-      slides,
-      codeLab
-    });
-    const allFindings = [...structuralResult.findings];
-    const strengths = [...structuralResult.strengths];
-    let semanticScore = null;
-    let semanticVerdict = "PASS";
-    if (executeLLMJudge) {
-      try {
-        const judgeReport = await auditCurriculumQualityFlow({
-          targetArtifactType: "LESSON_BUNDLE",
-          lessonId: lesson.lessonId,
-          expectedLanguage: lesson.language,
-          targetObjectives: (lesson.learningObjectives || []).map((lo) => ({
-            code: lo.code,
-            description: lo.description,
-            bloomLevel: lo.bloomLevel
-          })),
-          generatedContentJson: JSON.stringify({ lesson, quiz, activity, slides, codeLab }),
-          modelOptions
-        });
-        semanticScore = judgeReport.totalScore;
-        semanticVerdict = judgeReport.overallVerdict;
-        for (const criterion of judgeReport.criteria) {
-          if (!criterion.passed) {
-            allFindings.push({
-              id: `llm_judge_${criterion.name.toLowerCase().replace(/\s+/g, "_")}`,
-              dimension: "CONSTRUCTIVE_ALIGNMENT",
-              severity: criterion.score < 50 ? "CRITICAL" : "MAJOR",
-              title: `LLM-as-Judge Finding: ${criterion.name}`,
-              description: criterion.feedback,
-              remediationAdvice: judgeReport.actionableRepairPrompts.join("; ") || "Refine prompt context."
-            });
-          } else {
-            strengths.push(`[LLM-Judge] ${criterion.name}: ${criterion.feedback}`);
-          }
+  static evaluateLesson(lesson) {
+    const findings = [];
+    const strengths = [];
+    let score = 100;
+    if (!lesson.hookScenario || lesson.hookScenario.trim().length < 30) {
+      score -= 20;
+      findings.push({
+        id: "5e_weak_hook",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: "MAJOR",
+        title: "Shallow or Missing Real-World Hook",
+        description: "The lesson lacks a compelling, high-stakes real-world scenario to trigger inquiry.",
+        remediationAdvice: "Frame the lesson around an authentic engineering or domain problem (e.g. server crash, sensor failure, clinical anomaly)."
+      });
+    } else {
+      strengths.push("Engaging real-world hook scenario sets high-stakes context for inquiry.");
+    }
+    if (!lesson.hookQuestions || lesson.hookQuestions.length < 2) {
+      score -= 10;
+      findings.push({
+        id: "5e_insufficient_hook_questions",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: "MINOR",
+        title: "Insufficient Inquiry Questions in Hook",
+        description: "Need at least 2 open-ended inquiry questions in the Engage phase to activate prior mental models.",
+        remediationAdvice: "Add 2-3 provocative questions challenging common student assumptions."
+      });
+    }
+    const sections = lesson.sections || [];
+    const coveredStages = /* @__PURE__ */ new Set();
+    for (const section of sections) {
+      for (const stage of FIVE_E_STAGES) {
+        if (stage.regex.test(section.title)) {
+          coveredStages.add(stage.key);
         }
-      } catch (err) {
-        semanticScore = null;
-        semanticVerdict = "FAIL";
-        allFindings.push({
-          id: "llm_judge_connection_error",
-          dimension: "CONSTRUCTIVE_ALIGNMENT",
-          severity: "MINOR",
-          title: "LLM-as-Judge Skipped / Fallback",
-          description: `Semantic inference error: ${err.message || String(err)}`,
-          remediationAdvice: "Check API credentials for LLM-as-Judge."
-        });
       }
     }
-    const criticalCount = allFindings.filter((f) => f.severity === "CRITICAL").length;
-    const overallScore = executeLLMJudge && semanticScore !== null ? Math.round(structuralResult.structuralScore * 0.4 + semanticScore * 0.6) : structuralResult.structuralScore;
-    const passed = structuralResult.passed && criticalCount === 0 && (executeLLMJudge ? semanticVerdict === "PASS" : true);
-    let verdict = "REJECTED";
-    if (overallScore >= 90 && criticalCount === 0) {
-      verdict = "EXEMPLARY";
-    } else if (overallScore >= 75 && criticalCount === 0) {
-      verdict = "ACADEMICALLY_SOUND";
-    } else if (overallScore >= 60) {
-      verdict = "NEEDS_PEDAGOGICAL_REFINEMENT";
+    if (lesson.hookScenario) coveredStages.add("engage");
+    if (lesson.exitTicket) coveredStages.add("evaluate");
+    const missingStages = FIVE_E_STAGES.filter((s) => !coveredStages.has(s.key));
+    if (missingStages.length > 0) {
+      score -= missingStages.length * 10;
+      findings.push({
+        id: "5e_missing_phases",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: missingStages.length > 2 ? "CRITICAL" : "MAJOR",
+        title: `Incomplete 5E Instructional Cycle (Missing ${missingStages.length} phase(s))`,
+        description: `Lesson plan does not clearly demarcate: ${missingStages.map((s) => s.label).join(", ")}.`,
+        remediationAdvice: "Ensure the lesson explicitly walks through Engage -> Explore -> Explain -> Elaborate -> Evaluate."
+      });
+    } else {
+      strengths.push("Full 5E Instructional Cycle (Engage, Explore, Explain, Elaborate, Evaluate) is completely covered.");
     }
-    const summary = passed ? `\u2705 Lesson Bundle "${lesson.title}" (${lesson.lessonId}) passes academic & structural verification with score ${overallScore}/100 (${verdict}).` : `\u26A0\uFE0F Lesson Bundle "${lesson.title}" requires revision (${overallScore}/100 - ${verdict}). Found ${allFindings.length} finding(s) with ${criticalCount} critical blocker(s).`;
-    const actionablePromptGuidance = allFindings.map(
-      (f, idx) => `[${f.dimension}] ${idx + 1}. ${f.title}: ${f.remediationAdvice}`
-    );
-    const computeDimScore = (dimFindings2) => {
-      const hasCritical = dimFindings2.some((f) => f.severity === "CRITICAL");
-      const majorCount = dimFindings2.filter((f) => f.severity === "MAJOR").length;
-      const minorCount = dimFindings2.filter((f) => f.severity === "MINOR").length;
-      let dimScore = 100 - (hasCritical ? 40 : 0) - majorCount * 15 - minorCount * 5;
-      dimScore = Math.max(0, Math.min(100, dimScore));
-      return { score: dimScore, passed: dimScore >= 75 && !hasCritical };
-    };
-    const dimFindings = {
-      constructiveAlignment: allFindings.filter((f) => f.dimension === "CONSTRUCTIVE_ALIGNMENT"),
-      bloomProgression: allFindings.filter((f) => f.dimension === "BLOOM_PROGRESSION"),
-      fiveEFidelity: allFindings.filter((f) => f.dimension === "5E_INSTRUCTIONAL_FIDELITY"),
-      misconceptionRigor: allFindings.filter((f) => f.dimension === "MISCONCEPTION_RIGOR"),
-      technicalAuthenticity: allFindings.filter((f) => f.dimension === "TECHNICAL_AUTHENTICITY")
-    };
-    const dimScores = Object.fromEntries(
-      Object.entries(dimFindings).map(([k, v]) => [k, computeDimScore(v)])
-    );
+    let passiveSections = 0;
+    for (let i = 0; i < sections.length; i++) {
+      const s = sections[i];
+      const studentAct = (s.studentActions || "").trim().toLowerCase();
+      if (studentAct.includes("nghe gi\u1EA3ng") || studentAct.includes("ch\xE9p b\xE0i") || studentAct.includes("listen passively") || studentAct.length < 10) {
+        passiveSections++;
+      }
+    }
+    if (passiveSections > 0 && sections.length > 0) {
+      score -= passiveSections * 8;
+      findings.push({
+        id: "5e_passive_student_roles",
+        dimension: "5E_INSTRUCTIONAL_FIDELITY",
+        severity: "MAJOR",
+        title: "Passive Student Roles Detected in Lesson Sections",
+        description: `${passiveSections} section(s) assign passive roles (listening/copying) to students rather than active inquiry, pair-discussion, or hands-on experimentation.`,
+        remediationAdvice: "Transform student actions into active tasks (e.g. Think-Pair-Share, code tracing, hypothesis testing, live bug hunting)."
+      });
+    } else if (sections.length > 0) {
+      strengths.push("Student roles emphasize active learning and hands-on participation throughout.");
+    }
+    score = Math.max(0, Math.min(100, score));
     return {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      targetId: lesson.lessonId,
-      targetType: "BUNDLE",
-      overallScore,
-      passed,
-      verdict,
-      summary,
-      dimensionScores: {
-        constructiveAlignment: {
-          score: dimScores.constructiveAlignment.score,
-          weight: 0.2,
-          passed: dimScores.constructiveAlignment.passed,
-          strengths: dimScores.constructiveAlignment.passed ? ["Constructive alignment verified."] : [],
-          findings: dimFindings.constructiveAlignment
-        },
-        bloomProgression: {
-          score: dimScores.bloomProgression.score,
-          weight: 0.2,
-          passed: dimScores.bloomProgression.passed,
-          strengths: dimScores.bloomProgression.passed ? ["Bloom taxonomy progression verified."] : [],
-          findings: dimFindings.bloomProgression
-        },
-        fiveEFidelity: {
-          score: dimScores.fiveEFidelity.score,
-          weight: 0.15,
-          passed: dimScores.fiveEFidelity.passed,
-          strengths: dimScores.fiveEFidelity.passed ? ["5E instructional fidelity verified."] : [],
-          findings: dimFindings.fiveEFidelity
-        },
-        misconceptionRigor: {
-          score: dimScores.misconceptionRigor.score,
-          weight: 0.2,
-          passed: dimScores.misconceptionRigor.passed,
-          strengths: dimScores.misconceptionRigor.passed ? ["Misconception rigor verified."] : [],
-          findings: dimFindings.misconceptionRigor
-        },
-        technicalAuthenticity: {
-          score: dimScores.technicalAuthenticity.score,
-          weight: 0.15,
-          passed: dimScores.technicalAuthenticity.passed,
-          strengths: dimScores.technicalAuthenticity.passed ? ["Technical authenticity verified."] : [],
-          findings: dimFindings.technicalAuthenticity
-        },
-        crossArtifactZeroDrift: {
-          score: structuralResult.structuralScore,
-          weight: 0.1,
-          passed: structuralResult.passed,
-          strengths: structuralResult.passed ? ["Cross-artifact zero drift verified."] : [],
-          findings: allFindings.filter((f) => f.dimension === "CROSS_ARTIFACT_ZERO_DRIFT")
-        }
-      },
-      criticalFindingsCount: criticalCount,
-      allFindings,
-      actionablePromptGuidance
+      score,
+      weight: 0.15,
+      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
+      strengths,
+      findings
     };
   }
 };
 
-// src/evaluators/bloomTaxonomyEvaluator.ts
-var BLOOM_ACTION_VERBS = {
-  remember: [
-    "list",
-    "define",
-    "recall",
-    "state",
-    "name",
-    "identify",
-    "label",
-    "recognize",
-    "li\u1EC7t k\xEA",
-    "\u0111\u1ECBnh ngh\u0129a",
-    "g\u1ECDi t\xEAn",
-    "nh\u1EADn di\u1EC7n",
-    "ch\u1EC9 ra",
-    "nh\u1EAFc l\u1EA1i",
-    "ghi nh\u1EDB"
-  ],
-  understand: [
-    "explain",
-    "describe",
-    "summarize",
-    "classify",
-    "interpret",
-    "predict",
-    "trace",
-    "paraphrase",
-    "gi\u1EA3i th\xEDch",
-    "m\xF4 t\u1EA3",
-    "t\xF3m t\u1EAFt",
-    "ph\xE2n lo\u1EA1i",
-    "di\u1EC5n gi\u1EA3i",
-    "d\u1EF1 \u0111o\xE1n",
-    "l\u1EA7n theo",
-    "hi\u1EC3u"
-  ],
-  apply: [
-    "implement",
-    "execute",
-    "calculate",
-    "solve",
-    "construct",
-    "debug",
-    "modify",
-    "build",
-    "\xE1p d\u1EE5ng",
-    "th\u1EF1c thi",
-    "t\xEDnh to\xE1n",
-    "gi\u1EA3i quy\u1EBFt",
-    "x\xE2y d\u1EF1ng",
-    "s\u1EEDa l\u1ED7i",
-    "l\u1EAFp \u0111\u1EB7t",
-    "vi\u1EBFt m\xE3",
-    "l\u1EADp tr\xECnh"
-  ],
-  analyze: [
-    "compare",
-    "contrast",
-    "decompose",
-    "differentiate",
-    "troubleshoot",
-    "diagnose",
-    "deconstruct",
-    "so s\xE1nh",
-    "\u0111\u1ED1i chi\u1EBFu",
-    "ph\xE2n t\xEDch",
-    "ph\xE2n r\xE3",
-    "ch\u1EA9n \u0111o\xE1n",
-    "t\xECm nguy\xEAn nh\xE2n g\u1ED1c",
-    "b\xF3c t\xE1ch"
-  ],
-  evaluate: [
-    "justify",
-    "critique",
-    "assess",
-    "defend",
-    "argue",
-    "benchmark",
-    "prioritize",
-    "\u0111\xE1nh gi\xE1",
-    "bi\u1EC7n minh",
-    "ph\xEA ph\xE1n",
-    "th\u1EA9m \u0111\u1ECBnh",
-    "b\u1EA3o v\u1EC7 quan \u0111i\u1EC3m",
-    "l\u1EF1a ch\u1ECDn t\u1ED1i \u01B0u"
-  ],
-  create: [
-    "design",
-    "synthesize",
-    "architect",
-    "formulate",
-    "invent",
-    "devise",
-    "author",
-    "thi\u1EBFt k\u1EBF",
-    "t\u1ED5ng h\u1EE3p",
-    "s\xE1ng t\u1EA1o",
-    "ki\u1EBFn tr\xFAc",
-    "ph\xE1t minh",
-    "ho\xE0n thi\u1EC7n \u0111\u1ED3 \xE1n"
-  ]
-};
-var RECALL_PATTERNS = [
-  /^(?:chức năng chính của|định nghĩa của|cú pháp của|lệnh nào là|what is the definition of|which keyword|what does .* stand for)/i,
-  /(?:là gì\?|được gọi là gì\?|có ý nghĩa gì\?)/i
+// src/evaluators/codeHardwareFeasibilityEvaluator.ts
+var VALID_MERMAID_STARTERS = [
+  "graph",
+  "flowchart",
+  "sequencediagram",
+  "statediagram",
+  "classdiagram",
+  "erdiagram",
+  "gantt",
+  "gitgraph"
 ];
-var BloomTaxonomyEvaluator = class {
+var CodeHardwareFeasibilityEvaluator = class {
   /**
-   * Audits a LessonPlan for Bloom taxonomy fidelity and cognitive scaffolding.
+   * Audits technical accuracy, code syntax sanity, and hardware circuit safety.
    */
-  static evaluateLesson(lesson) {
+  static evaluateTechnicalFeasibility(lesson, codeLab, activity) {
     const findings = [];
     const strengths = [];
     let score = 100;
-    const los = lesson.learningObjectives || [];
-    if (los.length === 0) {
-      return {
-        score: 0,
-        weight: 0.2,
-        passed: false,
-        strengths: [],
-        findings: [
-          {
-            id: "bloom_missing_los",
-            dimension: "BLOOM_PROGRESSION",
-            severity: "CRITICAL",
-            title: "Missing Learning Objectives",
-            description: "The lesson plan contains zero declared Learning Objectives.",
-            remediationAdvice: "Add 2-4 clearly articulated LOs with Bloom levels and observable success criteria."
-          }
-        ]
-      };
-    }
-    for (const lo of los) {
-      const declaredLevel = (lo.bloomLevel || "").toLowerCase();
-      const text = `${lo.name || ""} ${lo.description || ""} ${lo.successCriteria || ""}`.toLowerCase();
-      const isRecallPattern = RECALL_PATTERNS.some((p) => p.test(text));
-      if (isRecallPattern && (declaredLevel === "apply" || declaredLevel === "analyze" || declaredLevel === "evaluate")) {
-        score -= 15;
+    if (lesson?.guidedPractice) {
+      const { codeSnippet, codeLanguage, mermaidDiagram } = lesson.guidedPractice;
+      if (!codeSnippet || codeSnippet.trim().length < 15) {
+        score -= 20;
         findings.push({
-          id: `bloom_inflation_${lo.code}`,
-          dimension: "BLOOM_PROGRESSION",
+          id: "tech_empty_guided_code",
+          dimension: "TECHNICAL_AUTHENTICITY",
           severity: "MAJOR",
-          title: `Bloom Level Inflation in LO "${lo.code}"`,
-          description: `LO is tagged as "${lo.bloomLevel}" but its phrasing reflects low-level Recall ("${lo.description}").`,
-          remediationAdvice: `Rewrite the objective using authentic "${declaredLevel}" active verbs (e.g. build, debug, compare, diagnose) with an explicit application context.`,
-          affectedElement: lo.code
+          title: "Empty or Trivial Guided Practice Code",
+          description: "Guided practice lacks runnable code snippet or domain calculation template.",
+          remediationAdvice: "Provide a complete, runnable code example with explanatory line-by-line comments."
         });
+      } else {
+        if (codeLanguage?.toLowerCase() === "arduino" || codeLanguage?.toLowerCase() === "cpp" || codeSnippet.includes("pinMode")) {
+          if (codeSnippet.includes("digitalWrite") && !codeSnippet.includes("pinMode") && !codeSnippet.includes("setup()")) {
+            score -= 15;
+            findings.push({
+              id: "tech_arduino_missing_pinmode",
+              dimension: "TECHNICAL_AUTHENTICITY",
+              severity: "MAJOR",
+              title: "Missing pinMode() Configuration in Arduino Code",
+              description: "Code calls `digitalWrite()` without initializing the pin with `pinMode(pin, OUTPUT)`.",
+              remediationAdvice: "Ensure `setup()` configures pin direction before writing digital states."
+            });
+          }
+          if (codeSnippet.includes("delay(0)") || codeSnippet.includes("delay(-")) {
+            score -= 15;
+            findings.push({
+              id: "tech_arduino_invalid_delay",
+              dimension: "TECHNICAL_AUTHENTICITY",
+              severity: "MAJOR",
+              title: "Invalid delay() Parameter",
+              description: "delay() duration must be a positive integer in milliseconds.",
+              remediationAdvice: "Use realistic delay timings (e.g. 500ms, 1000ms)."
+            });
+          }
+        }
+        strengths.push("Guided practice features runnable code snippet with clear syntax.");
       }
-      if (!lo.successCriteria || lo.successCriteria.trim().length < 15) {
-        score -= 10;
+      if (mermaidDiagram) {
+        const cleanDiagram = mermaidDiagram.trim().toLowerCase();
+        const isValidStarter = VALID_MERMAID_STARTERS.some((starter) => cleanDiagram.startsWith(starter));
+        if (!isValidStarter) {
+          score -= 15;
+          findings.push({
+            id: "tech_invalid_mermaid_syntax",
+            dimension: "TECHNICAL_AUTHENTICITY",
+            severity: "MAJOR",
+            title: "Invalid Mermaid Diagram Syntax",
+            description: `Mermaid diagram does not start with a valid declaration (e.g. "flowchart TD", "graph TD", "sequenceDiagram"). Got: "${mermaidDiagram.substring(0, 30)}..."`,
+            remediationAdvice: "Format Mermaid diagrams starting with `flowchart TD` or `sequenceDiagram`."
+          });
+        } else {
+          strengths.push("Valid Mermaid architectural diagram included.");
+        }
+      }
+    }
+    if (codeLab) {
+      const starter = codeLab.starterCode?.content || "";
+      const solution = codeLab.solutionCode?.content || "";
+      if (starter.length < 20 || solution.length < 20) {
+        score -= 25;
         findings.push({
-          id: `bloom_unmeasurable_criteria_${lo.code}`,
-          dimension: "BLOOM_PROGRESSION",
-          severity: "MINOR",
-          title: `Vague Success Criteria in LO "${lo.code}"`,
-          description: `Success criteria "${lo.successCriteria || ""}" is too brief to provide objective student evidence.`,
-          remediationAdvice: 'Specify concrete, observable evidence (e.g. "LED blinks with 1s period without circuit shorting").',
-          affectedElement: lo.code
+          id: "tech_codelab_incomplete_codes",
+          dimension: "TECHNICAL_AUTHENTICITY",
+          severity: "CRITICAL",
+          title: "Incomplete CodeLab Starter / Solution Code",
+          description: "CodeLab must provide both scaffolding starter code and complete reference solution code.",
+          remediationAdvice: "Populate `starterCode` with TODO markers and `solutionCode` with tested implementation."
         });
       } else {
-        strengths.push(`LO "${lo.code}" defines concrete observable student evidence.`);
+        strengths.push("CodeLab provides complete starter skeleton and working solution code.");
       }
-    }
-    const diff = lesson.differentiation;
-    if (diff) {
-      if (!diff.bronzeTier || !diff.silverTier || !diff.goldTier) {
+      if (!codeLab.testCases || codeLab.testCases.length === 0) {
         score -= 15;
         findings.push({
-          id: "bloom_incomplete_differentiation",
-          dimension: "BLOOM_PROGRESSION",
+          id: "tech_codelab_missing_testcases",
+          dimension: "TECHNICAL_AUTHENTICITY",
           severity: "MAJOR",
-          title: "Incomplete 3-Tier Scaffolding",
-          description: "Differentiation must provide distinct Bronze (Foundation), Silver (Application), and Gold (Extension) challenges.",
-          remediationAdvice: "Define all 3 tiers with increasing cognitive demands (Remember/Understand -> Apply -> Analyze/Create)."
+          title: "Missing Automated Verification Test Cases",
+          description: "CodeLab lacks test cases for students to self-verify their implementations.",
+          remediationAdvice: "Add at least 2 concrete test cases with input and expected output assertions."
         });
-      } else {
-        strengths.push("Complete 3-tier scaffolding (Bronze -> Silver -> Gold) present in Lesson Plan.");
       }
-    } else {
-      score -= 20;
-      findings.push({
-        id: "bloom_missing_differentiation",
-        dimension: "BLOOM_PROGRESSION",
-        severity: "CRITICAL",
-        title: "Missing Differentiation Scaffolding",
-        description: "Lesson plan lacks differentiation tiers.",
-        remediationAdvice: "Provide tiered practice instructions for varied learner paces."
-      });
     }
-    score = Math.max(0, Math.min(100, score));
-    return {
-      score,
-      weight: 0.2,
-      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
-      strengths,
-      findings
-    };
-  }
-  /**
-   * Audits a Diagnostic Quiz for true cognitive depth matching declared Bloom levels.
-   */
-  static evaluateQuiz(quiz) {
-    const findings = [];
-    const strengths = [];
-    let score = 100;
-    const questions = quiz.questions || [];
-    if (questions.length < 3) {
-      score -= 30;
-      findings.push({
-        id: "bloom_quiz_too_short",
-        dimension: "BLOOM_PROGRESSION",
-        severity: "MAJOR",
-        title: "Insufficient Question Pool",
-        description: `Quiz only contains ${questions.length} questions. Minimum diagnostic threshold is 3 questions.`,
-        remediationAdvice: "Generate at least 3-5 diagnostic questions covering foundational through analytical depth."
-      });
-    }
-    let understandCount = 0;
-    let applyCount = 0;
-    let analyzeCount = 0;
-    for (let i = 0; i < questions.length; i++) {
-      const q = questions[i];
-      const qId = q.id || `Q${i + 1}`;
-      const declaredBloom = (q.bloomLevel || "").toLowerCase();
-      const stem = q.scenarioOrStem || "";
-      if (declaredBloom === "understand") understandCount++;
-      if (declaredBloom === "apply") applyCount++;
-      if (declaredBloom === "analyze" || declaredBloom === "evaluate") analyzeCount++;
-      const isRecall = RECALL_PATTERNS.some((p) => p.test(stem));
-      if (isRecall && (declaredBloom === "apply" || declaredBloom === "analyze")) {
-        score -= 15;
-        findings.push({
-          id: `bloom_quiz_misclassification_${qId}`,
-          dimension: "BLOOM_PROGRESSION",
-          severity: "MAJOR",
-          title: `Cognitive Level Misclassification in ${qId}`,
-          description: `Question stem "${stem.substring(0, 60)}..." is pure Recall/Definition, but is tagged as "${q.bloomLevel}".`,
-          remediationAdvice: 'Either re-tag as "understand" or transform the stem into an authentic problem-solving scenario requiring code debugging or design decision.',
-          affectedElement: qId
-        });
-      }
-      if ((declaredBloom === "apply" || declaredBloom === "analyze") && !q.codeSnippet && !stem.includes("```") && !stem.includes("m\u1EA1ch")) {
-        score -= 10;
-        findings.push({
-          id: `bloom_quiz_missing_code_context_${qId}`,
-          dimension: "BLOOM_PROGRESSION",
-          severity: "MINOR",
-          title: `Missing Practical Context in High-Bloom Question ${qId}`,
-          description: `Question ${qId} tagged as "${q.bloomLevel}" lacks concrete code or circuit context to evaluate hands-on execution.`,
-          remediationAdvice: "Include an annotated code snippet or circuit state for students to trace, debug, or evaluate.",
-          affectedElement: qId
-        });
-      }
-    }
-    if (questions.length > 0 && (understandCount > 0 || applyCount > 0)) {
-      strengths.push(`Quiz features multi-level cognitive questions (Understand: ${understandCount}, Apply: ${applyCount}, Analyze: ${analyzeCount}).`);
-    }
-    score = Math.max(0, Math.min(100, score));
-    return {
-      score,
-      weight: 0.2,
-      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
-      strengths,
-      findings
-    };
-  }
-};
-
-// src/evaluators/crossArtifactDriftEvaluator.ts
-var CrossArtifactDriftEvaluator = class {
-  /**
-   * Audits consistency, metadata synchronization, and zero-drift across all artifacts in a lesson bundle.
-   */
-  static evaluateBundle(lesson, quiz, activity, slides) {
-    const findings = [];
-    const strengths = [];
-    let score = 100;
-    const baseLessonId = lesson.lessonId;
-    const baseLanguage = lesson.language;
-    if (quiz && quiz.quizId && quiz.quizId !== baseLessonId && !quiz.quizId.includes(baseLessonId)) {
-      score -= 15;
-      findings.push({
-        id: "drift_quiz_id_mismatch",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "MAJOR",
-        title: "Quiz ID Mismatch with Master Lesson",
-        description: `Quiz ID "${quiz.quizId}" diverges from master Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Align Quiz ID to "${baseLessonId}".`,
-        affectedElement: quiz.quizId
-      });
-    }
-    if (activity && activity.lessonId && activity.lessonId !== baseLessonId) {
-      score -= 15;
-      findings.push({
-        id: "drift_act_id_mismatch",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "MAJOR",
-        title: "Activity Lesson ID Mismatch",
-        description: `Activity lessonId "${activity.lessonId}" diverges from master Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Align Activity lessonId to "${baseLessonId}".`,
-        affectedElement: activity.lessonId
-      });
-    }
-    if (slides && slides.lessonId && slides.lessonId !== baseLessonId) {
-      score -= 15;
-      findings.push({
-        id: "drift_slides_id_mismatch",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "MAJOR",
-        title: "Slide Deck Lesson ID Mismatch",
-        description: `Slide deck lessonId "${slides.lessonId}" diverges from master Lesson ID "${baseLessonId}".`,
-        remediationAdvice: `Align Slide deck lessonId to "${baseLessonId}".`,
-        affectedElement: slides.lessonId
-      });
-    }
-    const satellites = [
-      { type: "QUIZ", lang: quiz?.language },
-      { type: "ACT", lang: activity?.language },
-      { type: "SLIDE", lang: slides?.language }
-    ];
-    for (const sat of satellites) {
-      if (sat.lang && sat.lang.toLowerCase() !== baseLanguage.toLowerCase()) {
-        score -= 25;
+    if (activity?.materialsBOM?.hardware && activity.materialsBOM.hardware.length > 0) {
+      const hwText = activity.materialsBOM.hardware.join(" ").toLowerCase();
+      const hasLED = hwText.includes("led");
+      const hasResistor = hwText.includes("\u0111i\u1EC7n tr\u1EDF") || hwText.includes("resistor") || hwText.includes("220") || hwText.includes("330") || hwText.includes("1k");
+      if (hasLED && !hasResistor) {
+        score -= 20;
         findings.push({
-          id: `drift_language_mismatch_${sat.type}`,
-          dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
+          id: "tech_hardware_unsafe_led_no_resistor",
+          dimension: "TECHNICAL_AUTHENTICITY",
           severity: "CRITICAL",
-          title: `Language Contamination in ${sat.type}`,
-          description: `Master Lesson is in "${baseLanguage}" but ${sat.type} is declared in "${sat.lang}".`,
-          remediationAdvice: `Regenerate ${sat.type} strictly in "${baseLanguage}".`
+          title: "Dangerous Hardware Circuit: LED without Current-Limiting Resistor",
+          description: "Activity specifies an LED on breadboard/microcontroller without a 220\u03A9-1k\u03A9 current-limiting resistor, which causes electrical overload and burnout.",
+          remediationAdvice: "Add a 220\u03A9 or 330\u03A9 current-limiting resistor to the hardware BOM."
         });
+      } else if (hasLED && hasResistor) {
+        strengths.push("Hardware BOM safely pairs LED with current-limiting resistor protection.");
       }
     }
-    const sections = lesson.sections || [];
-    const totalSectionMins = sections.reduce((sum, s) => sum + (s.durationMinutes || 0), 0);
-    if (totalSectionMins > 0 && (totalSectionMins < 40 || totalSectionMins > 180)) {
-      score -= 10;
-      findings.push({
-        id: "drift_unrealistic_lesson_duration",
-        dimension: "CROSS_ARTIFACT_ZERO_DRIFT",
-        severity: "MINOR",
-        title: `Unrealistic Lesson Flow Total Duration (${totalSectionMins} mins)`,
-        description: `Sum of 5E section durations is ${totalSectionMins} minutes. Standard K-12/College lessons span 45-120 minutes.`,
-        remediationAdvice: "Adjust individual section timings so total duration matches standard classroom blocks (e.g. 60m or 90m)."
-      });
-    } else if (totalSectionMins > 0) {
-      strengths.push(`Lesson section timings sum up to a realistic classroom block (${totalSectionMins} mins).`);
-    }
-    if (score >= 90) {
-      strengths.push("Zero drift verified: IDs, language policies, and pedagogical contracts are strictly aligned across all artifacts.");
-    }
     score = Math.max(0, Math.min(100, score));
     return {
       score,
-      weight: 0.1,
+      weight: 0.15,
       passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
       strengths,
       findings
@@ -16206,19 +15695,22 @@ var CrossArtifactDriftEvaluator = class {
   }
 };
 
-// src/evaluators/constructiveAlignmentEvaluator.ts
-var ConstructiveAlignmentEvaluator = class {
+// src/evaluators/misconceptionEvaluator.ts
+var LAZY_DISTRACTOR_PATTERNS = [
+  /^(?:tất cả các đáp án trên đều (?:đúng|sai)|cả a,?\s*b,?\s*c đều (?:đúng|sai)|all of the above|none of the above)[\.\?!]?$/i,
+  /^(?:không có đáp án nào đúng|không có chức năng|không làm gì cả|không ảnh hưởng)[\.\?!]?$/i,
+  /^(?:đáp án khác|other)[\.\?!]?$/i
+];
+var MisconceptionEvaluator = class {
   /**
-   * Evaluates constructive alignment within a LessonPlan and across its satellite artifacts.
+   * Audits the psychometric and pedagogical rigor of diagnostic questions and their distractors.
    */
-  static evaluateLesson(lesson, quiz, activity) {
+  static evaluateQuiz(quiz) {
     const findings = [];
     const strengths = [];
     let score = 100;
-    const los = lesson.learningObjectives || [];
-    const sections = lesson.sections || [];
-    const exitTicket = lesson.exitTicket;
-    if (los.length === 0) {
+    const questions = quiz.questions || [];
+    if (questions.length === 0) {
       return {
         score: 0,
         weight: 0.2,
@@ -16226,85 +15718,84 @@ var ConstructiveAlignmentEvaluator = class {
         strengths: [],
         findings: [
           {
-            id: "align_no_los",
-            dimension: "CONSTRUCTIVE_ALIGNMENT",
+            id: "misconception_no_questions",
+            dimension: "MISCONCEPTION_RIGOR",
             severity: "CRITICAL",
-            title: "No Learning Objectives Defined",
-            description: "Constructive alignment cannot be established without baseline LOs.",
-            remediationAdvice: "Define at least 2 measurable Learning Objectives."
+            title: "Empty Question Bank",
+            description: "No questions provided in quiz artifact.",
+            remediationAdvice: "Generate diagnostic questions with deliberate misconception traps."
           }
         ]
       };
     }
-    const combinedSectionText = sections.map((s) => `${s.title} ${s.teacherActions} ${s.studentActions} ${(s.analogies || []).join(" ")}`).join(" ").toLowerCase();
-    for (const lo of los) {
-      const loKeywords = (lo.name || lo.description || "").toLowerCase().split(/\s+/).filter((w) => w.length > 4);
-      const hasCoverage = loKeywords.some((k) => combinedSectionText.includes(k));
-      if (!hasCoverage && loKeywords.length > 0) {
+    let questionsWithFullExplanations = 0;
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      const qId = q.id || `Q${i + 1}`;
+      const options = q.options || [];
+      if (options.length < 4) {
         score -= 15;
         findings.push({
-          id: `align_uncovered_lo_${lo.code}`,
-          dimension: "CONSTRUCTIVE_ALIGNMENT",
+          id: `misconception_few_options_${qId}`,
+          dimension: "MISCONCEPTION_RIGOR",
           severity: "MAJOR",
-          title: `Untaught Objective in Lesson Flow: "${lo.code}"`,
-          description: `The LO "${lo.name || lo.code}" is declared in the objectives table but receives minimal coverage in the 5E lesson sections.`,
-          remediationAdvice: `Add explicit Teacher Moves and Student Actions in the Explore/Explain sections addressing "${lo.name}".`,
-          affectedElement: lo.code
+          title: `Insufficient Distractors in ${qId}`,
+          description: `Question ${qId} has only ${options.length} options. Standard diagnostic rigor requires 4 plausible choices (1 key + 3 diagnostic distractors).`,
+          remediationAdvice: "Provide 4 full options (A, B, C, D) representing distinct cognitive states.",
+          affectedElement: qId
         });
       }
-    }
-    if (!exitTicket || !exitTicket.questionStem || exitTicket.questionStem.trim().length < 15) {
-      score -= 15;
-      findings.push({
-        id: "align_missing_exit_ticket",
-        dimension: "CONSTRUCTIVE_ALIGNMENT",
-        severity: "MAJOR",
-        title: "Missing or Shallow Exit Ticket",
-        description: "The lesson ends without a rigorous formative Exit Ticket to measure LO attainment before class dismissal.",
-        remediationAdvice: "Include an Exit Ticket question matching the primary LO + a metacognitive reflection prompt."
-      });
-    } else {
-      strengths.push("Formative Exit Ticket is properly anchored at the conclusion of the lesson.");
-    }
-    if (quiz) {
-      const quizQuestions = quiz.questions || [];
-      if (quizQuestions.length > 0) {
-        const quizText = quizQuestions.map((q) => `${q.scenarioOrStem} ${(q.options || []).map((o) => o.text).join(" ")}`).join(" ").toLowerCase();
-        const lessonTopicKeywords = (lesson.topic || lesson.title || "").toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-        const hasTopicMatch = lessonTopicKeywords.some((k) => quizText.includes(k));
-        if (!hasTopicMatch && lessonTopicKeywords.length > 0) {
-          score -= 20;
-          findings.push({
-            id: "align_quiz_topic_divergence",
-            dimension: "CONSTRUCTIVE_ALIGNMENT",
-            severity: "CRITICAL",
-            title: "Quiz Topic Divergence from Lesson",
-            description: `Quiz questions do not reflect the main topic "${lesson.topic}" of the master lesson.`,
-            remediationAdvice: "Re-align quiz questions strictly to the core concepts taught in the lesson."
-          });
-        } else {
-          strengths.push("Diagnostic Quiz questions tightly reflect the lesson topic and concepts.");
-        }
-      }
-    }
-    if (activity) {
-      const actObj = (activity.objective || "").toLowerCase();
-      const lessonTitleLower = (lesson.title || "").toLowerCase();
-      const hasActAlignment = los.some((lo) => actObj.includes((lo.name || "").toLowerCase()) || actObj.includes((lo.description || "").toLowerCase())) || actObj.includes(lessonTitleLower) || lessonTitleLower.split(/\s+/).some((w) => w.length > 4 && actObj.includes(w));
-      if (!hasActAlignment && activity.objective) {
-        score -= 15;
+      const correctCount = options.filter((o) => o.isCorrect).length;
+      if (correctCount !== 1) {
+        score -= 25;
         findings.push({
-          id: "align_act_objective_divergence",
-          dimension: "CONSTRUCTIVE_ALIGNMENT",
-          severity: "MAJOR",
-          title: "Activity Objective Disconnected from Lesson Plan",
-          description: `Activity objective "${activity.objective}" does not directly support the lesson LOs.`,
-          remediationAdvice: "Ensure the Activity hands-on lab operationalizes the exact LOs specified in the Master Lesson."
+          id: `misconception_invalid_correct_count_${qId}`,
+          dimension: "MISCONCEPTION_RIGOR",
+          severity: "CRITICAL",
+          title: `Key Assignment Error in ${qId}`,
+          description: `Question ${qId} has ${correctCount} correct options (must have exactly 1 true answer).`,
+          remediationAdvice: "Set `isCorrect: true` on exactly one option and `isCorrect: false` on all distractors.",
+          affectedElement: qId
+        });
+      }
+      let missingExplanation = false;
+      for (const opt of options) {
+        const text = (opt.text || "").trim();
+        const explanation = (opt.explanation || "").trim();
+        if (LAZY_DISTRACTOR_PATTERNS.some((p) => p.test(text))) {
+          score -= 10;
+          findings.push({
+            id: `misconception_lazy_distractor_${qId}_${opt.id}`,
+            dimension: "MISCONCEPTION_RIGOR",
+            severity: "MAJOR",
+            title: `Low-Utility Distractor in ${qId} (${opt.id})`,
+            description: `Option "${text}" is a generic/throwaway distractor ("All/None of the above" or "No effect") that does not diagnose student cognitive models.`,
+            remediationAdvice: "Replace with an authentic student misconception (e.g. inverted logic, missing pullup, off-by-one boundary, unit confusion).",
+            affectedElement: `${qId}.${opt.id}`
+          });
+        }
+        if (!explanation || explanation.length < 20) {
+          missingExplanation = true;
+        }
+      }
+      if (missingExplanation) {
+        score -= 10;
+        findings.push({
+          id: `misconception_shallow_explanation_${qId}`,
+          dimension: "MISCONCEPTION_RIGOR",
+          severity: "MAJOR",
+          title: `Shallow Distractor Explanations in ${qId}`,
+          description: `Question ${qId} lacks detailed pedagogical explanations for all options. Students and teachers cannot diagnose root causes without option-level rationale.`,
+          remediationAdvice: "For EVERY option (A, B, C, D), explicitly write why the choice is correct or what mental misconception it represents.",
+          affectedElement: qId
         });
       } else {
-        strengths.push("Activity lab objective directly operationalizes master lesson learning goals.");
+        questionsWithFullExplanations++;
       }
     }
+    if (questionsWithFullExplanations === questions.length && questions.length >= 3) {
+      strengths.push("All quiz questions feature rigorous 4-option breakdown with comprehensive misconception analysis.");
+    }
     score = Math.max(0, Math.min(100, score));
     return {
       score,
@@ -16316,345 +15807,287 @@ var ConstructiveAlignmentEvaluator = class {
   }
 };
 
-// src/evaluators/fiveEInstructionalEvaluator.ts
-var FIVE_E_STAGES = [
-  { key: "engage", label: "Engage (Kh\u1EDFi \u0111\u1ED9ng / M\xF3c neo)", regex: /(?:engage|khởi động|hook|mở đầu|anchor)/i },
-  { key: "explore", label: "Explore (Kh\xE1m ph\xE1 / Tr\u1EA3i nghi\u1EC7m)", regex: /(?:explore|khám phá|trải nghiệm|thử nghiệm)/i },
-  { key: "explain", label: "Explain (Gi\u1EA3i th\xEDch / H\xECnh th\xE0nh ki\u1EBFn th\u1EE9c)", regex: /(?:explain|giải thích|khái niệm|kiến thức cốt lõi)/i },
-  { key: "elaborate", label: "Elaborate (V\u1EADn d\u1EE5ng / M\u1EDF r\u1ED9ng)", regex: /(?:elaborate|vận dụng|luyện tập|thực hành|áp dụng)/i },
-  { key: "evaluate", label: "Evaluate (\u0110\xE1nh gi\xE1 / T\u1ED5ng k\u1EBFt)", regex: /(?:evaluate|đánh giá|tổng kết|wrap-up|exit ticket)/i }
-];
-var FiveEInstructionalEvaluator = class {
-  /**
-   * Evaluates the pedagogical structure of a Lesson Plan against the 5E Inquiry Model.
-   */
-  static evaluateLesson(lesson) {
-    const findings = [];
-    const strengths = [];
-    let score = 100;
-    if (!lesson.hookScenario || lesson.hookScenario.trim().length < 30) {
-      score -= 20;
-      findings.push({
-        id: "5e_weak_hook",
-        dimension: "5E_INSTRUCTIONAL_FIDELITY",
-        severity: "MAJOR",
-        title: "Shallow or Missing Real-World Hook",
-        description: "The lesson lacks a compelling, high-stakes real-world scenario to trigger inquiry.",
-        remediationAdvice: "Frame the lesson around an authentic engineering or domain problem (e.g. server crash, sensor failure, clinical anomaly)."
-      });
-    } else {
-      strengths.push("Engaging real-world hook scenario sets high-stakes context for inquiry.");
+// src/standards/standardsCoverageGate.ts
+function resolveStatementRef(ref, packs) {
+  const [head, ...rest] = ref.split(":");
+  const candidatePacks = rest.length > 0 ? packs.filter((p) => p.manifest.id === head) : packs;
+  const statementId = rest.length > 0 ? rest.join(":") : ref;
+  for (const p of candidatePacks) {
+    if (p.statements.some((s) => s.id === statementId)) return { pack: p, statementId };
+  }
+  return null;
+}
+function evaluateStandardsCoverage(input) {
+  const rows = [];
+  const aoToLo = /* @__PURE__ */ new Map();
+  for (const ao of input.assessmentObjectives ?? []) aoToLo.set(ao.aoCode, ao.alignedLO);
+  const loToRefs = /* @__PURE__ */ new Map();
+  for (const lo of input.objectives) {
+    loToRefs.set(lo.code, new Set(lo.standardRefs ?? []));
+  }
+  const taughtLOs = /* @__PURE__ */ new Set();
+  for (const act of input.activities ?? []) for (const lo of act.lo) taughtLOs.add(lo);
+  const assessedLOs = /* @__PURE__ */ new Set();
+  for (const q of input.quizQuestions) {
+    if (q.alignedLO) assessedLOs.add(q.alignedLO);
+    if (q.alignedAO) {
+      const lo = aoToLo.get(q.alignedAO);
+      if (lo) assessedLOs.add(lo);
     }
-    if (!lesson.hookQuestions || lesson.hookQuestions.length < 2) {
-      score -= 10;
-      findings.push({
-        id: "5e_insufficient_hook_questions",
-        dimension: "5E_INSTRUCTIONAL_FIDELITY",
-        severity: "MINOR",
-        title: "Insufficient Inquiry Questions in Hook",
-        description: "Need at least 2 open-ended inquiry questions in the Engage phase to activate prior mental models.",
-        remediationAdvice: "Add 2-3 provocative questions challenging common student assumptions."
-      });
+  }
+  for (const pack of input.packs) {
+    const mappingByStatement = /* @__PURE__ */ new Map();
+    for (const m of pack.mappings ?? []) {
+      const prev = mappingByStatement.get(m.statementId);
+      if (!prev || prev !== "covers" && m.kind === "covers" || prev === "extends" && m.kind !== "extends") {
+        mappingByStatement.set(m.statementId, m.kind);
+      }
     }
-    const sections = lesson.sections || [];
-    const coveredStages = /* @__PURE__ */ new Set();
-    for (const section of sections) {
-      for (const stage of FIVE_E_STAGES) {
-        if (stage.regex.test(section.title)) {
-          coveredStages.add(stage.key);
+    for (const statement of pack.statements) {
+      const refFull = `${pack.manifest.id}:${statement.id}`;
+      const issues = [];
+      const los = input.objectives.filter((lo) => (lo.standardRefs ?? []).some((r) => r === statement.id || r === refFull)).map((lo) => lo.code);
+      const kind = mappingByStatement.get(statement.id);
+      const hasMapping = kind !== void 0;
+      const isComplianceRelevant = kind === "covers";
+      const hasActivity = los.some((lo) => taughtLOs.has(lo));
+      const hasAssessment = los.some((lo) => assessedLOs.has(lo));
+      let status;
+      if (!hasMapping) status = "UNMAPPED";
+      else if (!isComplianceRelevant) status = "PARTIAL";
+      else if (los.length > 0 && hasActivity && hasAssessment) status = "COVERED";
+      else status = "UNCOVERED";
+      if (status === "UNCOVERED") {
+        if (los.length === 0) issues.push("No learning objective anchors this statement (missing standardRefs).");
+        else {
+          if (!hasActivity) issues.push(`Anchored LO(s) ${los.join(", ")} have no activity in lesson flow.`);
+          if (!hasAssessment) issues.push(`Anchored LO(s) ${los.join(", ")} are not measured by any quiz question.`);
         }
       }
-    }
-    if (lesson.hookScenario) coveredStages.add("engage");
-    if (lesson.exitTicket) coveredStages.add("evaluate");
-    const missingStages = FIVE_E_STAGES.filter((s) => !coveredStages.has(s.key));
-    if (missingStages.length > 0) {
-      score -= missingStages.length * 10;
-      findings.push({
-        id: "5e_missing_phases",
-        dimension: "5E_INSTRUCTIONAL_FIDELITY",
-        severity: missingStages.length > 2 ? "CRITICAL" : "MAJOR",
-        title: `Incomplete 5E Instructional Cycle (Missing ${missingStages.length} phase(s))`,
-        description: `Lesson plan does not clearly demarcate: ${missingStages.map((s) => s.label).join(", ")}.`,
-        remediationAdvice: "Ensure the lesson explicitly walks through Engage -> Explore -> Explain -> Elaborate -> Evaluate."
+      rows.push({
+        packId: pack.manifest.id,
+        statementId: statement.id,
+        statementText: Object.values(statement.texts)[0] ?? "",
+        status,
+        objectives: los,
+        hasActivity,
+        hasAssessment,
+        issues
       });
-    } else {
-      strengths.push("Full 5E Instructional Cycle (Engage, Explore, Explain, Elaborate, Evaluate) is completely covered.");
     }
-    let passiveSections = 0;
-    for (let i = 0; i < sections.length; i++) {
-      const s = sections[i];
-      const studentAct = (s.studentActions || "").trim().toLowerCase();
-      if (studentAct.includes("nghe gi\u1EA3ng") || studentAct.includes("ch\xE9p b\xE0i") || studentAct.includes("listen passively") || studentAct.length < 10) {
-        passiveSections++;
+  }
+  for (const lo of input.objectives) {
+    for (const r of lo.standardRefs ?? []) {
+      if (!resolveStatementRef(r, input.packs)) {
+        rows.push({
+          packId: "(unresolved)",
+          statementId: r,
+          statementText: "",
+          status: "UNCOVERED",
+          objectives: [lo.code],
+          hasActivity: false,
+          hasAssessment: false,
+          issues: [`standardRef "${r}" does not exist in any adopted pack \u2014 likely a hallucinated or stale ID`]
+        });
       }
     }
-    if (passiveSections > 0 && sections.length > 0) {
-      score -= passiveSections * 8;
-      findings.push({
-        id: "5e_passive_student_roles",
-        dimension: "5E_INSTRUCTIONAL_FIDELITY",
-        severity: "MAJOR",
-        title: "Passive Student Roles Detected in Lesson Sections",
-        description: `${passiveSections} section(s) assign passive roles (listening/copying) to students rather than active inquiry, pair-discussion, or hands-on experimentation.`,
-        remediationAdvice: "Transform student actions into active tasks (e.g. Think-Pair-Share, code tracing, hypothesis testing, live bug hunting)."
-      });
-    } else if (sections.length > 0) {
-      strengths.push("Student roles emphasize active learning and hands-on participation throughout.");
+  }
+  const complianceRows = rows.filter((r) => r.status !== "UNMAPPED" && r.status !== "PARTIAL");
+  const covered = complianceRows.filter((r) => r.status === "COVERED").length;
+  const coveragePct = complianceRows.length === 0 ? 100 : Math.round(covered / complianceRows.length * 100);
+  const unresolvedCount = rows.filter((r) => r.packId === "(unresolved)").length;
+  const verdict = unresolvedCount > 0 || coveragePct < 60 ? "FAIL" : coveragePct < 100 ? "WARN" : "PASS";
+  const lines = [
+    "# Standards Coverage Report",
+    "",
+    `- Verdict: **${verdict}**`,
+    `- Compliance coverage: **${coveragePct}%** (${covered}/${complianceRows.length} "covers" statements fully taught + assessed)`,
+    `- Unresolved standardRefs: ${unresolvedCount}`,
+    "",
+    "| Pack | Statement | Status | LOs | Activity | Assessment |",
+    "|---|---|---|---|---|---|",
+    ...rows.map(
+      (r) => `|${r.packId}|${r.statementId}|${r.status}|${r.objectives.join(", ") || "\u2014"}|${r.hasActivity ? "\u2713" : "\u2717"}|${r.hasAssessment ? "\u2713" : "\u2717"}|`
+    )
+  ];
+  const issueLines = rows.filter((r) => r.issues.length > 0).flatMap((r) => r.issues.map((i) => `- [${r.packId}:${r.statementId}] ${i}`));
+  if (issueLines.length > 0) lines.push("", "## Issues", ...issueLines);
+  return {
+    verdict,
+    coveragePct,
+    rows,
+    summary: `Standards coverage ${coveragePct}% \u2014 verdict ${verdict}`,
+    rawMarkdownReport: lines.join("\n")
+  };
+}
+var StandardsRegistryAdapter = class {
+  client;
+  constructor(config = {}) {
+    if (config.client) {
+      this.client = config.client;
+      return;
     }
-    score = Math.max(0, Math.min(100, score));
-    return {
-      score,
-      weight: 0.15,
-      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
-      strengths,
-      findings
-    };
+    const url = config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || "";
+    const key = config.supabaseServiceRoleKey || process.env.SUPABASE_SERVICE_ROLE_KEY || config.supabaseAnonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
+    if (!url || !key) {
+      throw new Error("StandardsRegistryAdapter: Supabase URL/key missing (pass client or env).");
+    }
+    this.client = supabaseJs.createClient(url, key);
   }
-};
-
-// src/evaluators/codeHardwareFeasibilityEvaluator.ts
-var VALID_MERMAID_STARTERS = [
-  "graph",
-  "flowchart",
-  "sequencediagram",
-  "statediagram",
-  "classdiagram",
-  "erdiagram",
-  "gantt",
-  "gitgraph"
-];
-var CodeHardwareFeasibilityEvaluator = class {
-  /**
-   * Audits technical accuracy, code syntax sanity, and hardware circuit safety.
-   */
-  static evaluateTechnicalFeasibility(lesson, codeLab, activity) {
-    const findings = [];
-    const strengths = [];
-    let score = 100;
-    if (lesson?.guidedPractice) {
-      const { codeSnippet, codeLanguage, mermaidDiagram } = lesson.guidedPractice;
-      if (!codeSnippet || codeSnippet.trim().length < 15) {
-        score -= 20;
-        findings.push({
-          id: "tech_empty_guided_code",
-          dimension: "TECHNICAL_AUTHENTICITY",
-          severity: "MAJOR",
-          title: "Empty or Trivial Guided Practice Code",
-          description: "Guided practice lacks runnable code snippet or domain calculation template.",
-          remediationAdvice: "Provide a complete, runnable code example with explanatory line-by-line comments."
-        });
-      } else {
-        if (codeLanguage?.toLowerCase() === "arduino" || codeLanguage?.toLowerCase() === "cpp" || codeSnippet.includes("pinMode")) {
-          if (codeSnippet.includes("digitalWrite") && !codeSnippet.includes("pinMode") && !codeSnippet.includes("setup()")) {
-            score -= 15;
-            findings.push({
-              id: "tech_arduino_missing_pinmode",
-              dimension: "TECHNICAL_AUTHENTICITY",
-              severity: "MAJOR",
-              title: "Missing pinMode() Configuration in Arduino Code",
-              description: "Code calls `digitalWrite()` without initializing the pin with `pinMode(pin, OUTPUT)`.",
-              remediationAdvice: "Ensure `setup()` configures pin direction before writing digital states."
-            });
-          }
-          if (codeSnippet.includes("delay(0)") || codeSnippet.includes("delay(-")) {
-            score -= 15;
-            findings.push({
-              id: "tech_arduino_invalid_delay",
-              dimension: "TECHNICAL_AUTHENTICITY",
-              severity: "MAJOR",
-              title: "Invalid delay() Parameter",
-              description: "delay() duration must be a positive integer in milliseconds.",
-              remediationAdvice: "Use realistic delay timings (e.g. 500ms, 1000ms)."
-            });
-          }
-        }
-        strengths.push("Guided practice features runnable code snippet with clear syntax.");
-      }
-      if (mermaidDiagram) {
-        const cleanDiagram = mermaidDiagram.trim().toLowerCase();
-        const isValidStarter = VALID_MERMAID_STARTERS.some((starter) => cleanDiagram.startsWith(starter));
-        if (!isValidStarter) {
-          score -= 15;
-          findings.push({
-            id: "tech_invalid_mermaid_syntax",
-            dimension: "TECHNICAL_AUTHENTICITY",
-            severity: "MAJOR",
-            title: "Invalid Mermaid Diagram Syntax",
-            description: `Mermaid diagram does not start with a valid declaration (e.g. "flowchart TD", "graph TD", "sequenceDiagram"). Got: "${mermaidDiagram.substring(0, 30)}..."`,
-            remediationAdvice: "Format Mermaid diagrams starting with `flowchart TD` or `sequenceDiagram`."
-          });
-        } else {
-          strengths.push("Valid Mermaid architectural diagram included.");
-        }
-      }
-    }
-    if (codeLab) {
-      const starter = codeLab.starterCode?.content || "";
-      const solution = codeLab.solutionCode?.content || "";
-      if (starter.length < 20 || solution.length < 20) {
-        score -= 25;
-        findings.push({
-          id: "tech_codelab_incomplete_codes",
-          dimension: "TECHNICAL_AUTHENTICITY",
-          severity: "CRITICAL",
-          title: "Incomplete CodeLab Starter / Solution Code",
-          description: "CodeLab must provide both scaffolding starter code and complete reference solution code.",
-          remediationAdvice: "Populate `starterCode` with TODO markers and `solutionCode` with tested implementation."
-        });
-      } else {
-        strengths.push("CodeLab provides complete starter skeleton and working solution code.");
-      }
-      if (!codeLab.testCases || codeLab.testCases.length === 0) {
-        score -= 15;
-        findings.push({
-          id: "tech_codelab_missing_testcases",
-          dimension: "TECHNICAL_AUTHENTICITY",
-          severity: "MAJOR",
-          title: "Missing Automated Verification Test Cases",
-          description: "CodeLab lacks test cases for students to self-verify their implementations.",
-          remediationAdvice: "Add at least 2 concrete test cases with input and expected output assertions."
-        });
-      }
+  // ─── Intake (write path — service role) ───────────────────────────────────
+  /** Persist a schema-validated pack as a new framework (status=draft). */
+  async importPack(pack, opts) {
+    const parsed = FrameworkPackSchema.safeParse(pack);
+    if (!parsed.success) {
+      throw new Error("importPack: pack failed schema validation: " + parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; "));
     }
-    if (activity?.materialsBOM?.hardware && activity.materialsBOM.hardware.length > 0) {
-      const hwText = activity.materialsBOM.hardware.join(" ").toLowerCase();
-      const hasLED = hwText.includes("led");
-      const hasResistor = hwText.includes("\u0111i\u1EC7n tr\u1EDF") || hwText.includes("resistor") || hwText.includes("220") || hwText.includes("330") || hwText.includes("1k");
-      if (hasLED && !hasResistor) {
-        score -= 20;
-        findings.push({
-          id: "tech_hardware_unsafe_led_no_resistor",
-          dimension: "TECHNICAL_AUTHENTICITY",
-          severity: "CRITICAL",
-          title: "Dangerous Hardware Circuit: LED without Current-Limiting Resistor",
-          description: "Activity specifies an LED on breadboard/microcontroller without a 220\u03A9-1k\u03A9 current-limiting resistor, which causes electrical overload and burnout.",
-          remediationAdvice: "Add a 220\u03A9 or 330\u03A9 current-limiting resistor to the hardware BOM."
-        });
-      } else if (hasLED && hasResistor) {
-        strengths.push("Hardware BOM safely pairs LED with current-limiting resistor protection.");
-      }
+    const p = parsed.data;
+    const { data: fw, error: fwErr } = await this.client.from("standards_frameworks").insert({
+      pack_id: p.manifest.id,
+      content_version: p.manifest.contentVersion,
+      name: p.manifest.name,
+      spec_version: p.manifest.specVersion,
+      subject: p.manifest.subject,
+      languages: p.manifest.languages,
+      grade_model: p.manifest.gradeModel,
+      provenance: p.manifest.provenance,
+      trust: p.manifest.trust,
+      status: "draft",
+      organization_code: opts?.organizationCode ?? (p.manifest.trust === "verified" ? null : p.manifest.provenance.importedBy?.replace(/^org:/, "") || null),
+      original_file_path: opts?.originalFilePath ?? null,
+      created_by: opts?.createdBy ?? null
+    }).select("id").single();
+    if (fwErr) throw new Error("importPack: framework insert failed: " + fwErr.message);
+    const frameworkId = fw.id;
+    const statementRows = p.statements.map((s) => ({
+      framework_id: frameworkId,
+      statement_id: s.id,
+      parent_statement_id: s.parentId ?? null,
+      grade_min: s.gradeBand[0],
+      grade_max: s.gradeBand[1],
+      texts: s.texts,
+      classifications: s.classifications ?? [],
+      bloom_hint: s.bloomHint ?? null,
+      keywords: s.keywords ?? [],
+      source_ref: s.sourceRef ?? null,
+      provenance: s.provenance
+    }));
+    const { error: stErr, count: stCount } = await this.client.from("standards_statements").insert(statementRows, { count: "exact" });
+    if (stErr) throw new Error("importPack: statement insert failed: " + stErr.message);
+    let mappingCount = 0;
+    if (p.mappings && p.mappings.length > 0) {
+      const mappingRows = p.mappings.map((m) => ({
+        framework_id: frameworkId,
+        statement_id: m.statementId,
+        target_ref: m.targetRef,
+        kind: m.kind,
+        confidence: m.confidence,
+        provenance: m.provenance
+      }));
+      const { error: mpErr, count: mpCount } = await this.client.from("standards_mappings").insert(mappingRows, { count: "exact" });
+      if (mpErr) throw new Error("importPack: mapping insert failed: " + mpErr.message);
+      mappingCount = mpCount ?? mappingRows.length;
     }
-    score = Math.max(0, Math.min(100, score));
-    return {
-      score,
-      weight: 0.15,
-      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
-      strengths,
-      findings
-    };
+    return { frameworkDbId: frameworkId, statementsInserted: stCount ?? statementRows.length, mappingsInserted: mappingCount };
   }
-};
-
-// src/evaluators/misconceptionEvaluator.ts
-var LAZY_DISTRACTOR_PATTERNS = [
-  /^(?:tất cả các đáp án trên đều (?:đúng|sai)|cả a,?\s*b,?\s*c đều (?:đúng|sai)|all of the above|none of the above)[\.\?!]?$/i,
-  /^(?:không có đáp án nào đúng|không có chức năng|không làm gì cả|không ảnh hưởng)[\.\?!]?$/i,
-  /^(?:đáp án khác|other)[\.\?!]?$/i
-];
-var MisconceptionEvaluator = class {
+  /** Activate a draft framework (immutable version is now live). */
+  async activatePack(frameworkDbId) {
+    const { error } = await this.client.from("standards_frameworks").update({ status: "active" }).eq("id", frameworkDbId).eq("status", "draft");
+    if (error) throw new Error("activatePack failed: " + error.message);
+  }
+  async deprecatePack(frameworkDbId) {
+    const { error } = await this.client.from("standards_frameworks").update({ status: "deprecated" }).eq("id", frameworkDbId);
+    if (error) throw new Error("deprecatePack failed: " + error.message);
+  }
+  async adoptPack(frameworkDbId, organizationCode, adoptedBy) {
+    const { error } = await this.client.from("standards_org_adoptions").upsert(
+      { framework_id: frameworkDbId, organization_code: organizationCode, adopted_by: adoptedBy ?? null },
+      { onConflict: "organization_code,framework_id" }
+    );
+    if (error) throw new Error("adoptPack failed: " + error.message);
+  }
+  // ─── Runtime (read path — generation) ─────────────────────────────────────
   /**
-   * Audits the psychometric and pedagogical rigor of diagnostic questions and their distractors.
+   * Load all packs usable by an org: platform packs (verified, org IS NULL) +
+   * org packs + org adoptions. Hydrated into the same FrameworkPack shape the
+   * in-memory Phase-1 components consume (injector / coverage gate / judge).
    */
-  static evaluateQuiz(quiz) {
-    const findings = [];
-    const strengths = [];
-    let score = 100;
-    const questions = quiz.questions || [];
-    if (questions.length === 0) {
-      return {
-        score: 0,
-        weight: 0.2,
-        passed: false,
-        strengths: [],
-        findings: [
-          {
-            id: "misconception_no_questions",
-            dimension: "MISCONCEPTION_RIGOR",
-            severity: "CRITICAL",
-            title: "Empty Question Bank",
-            description: "No questions provided in quiz artifact.",
-            remediationAdvice: "Generate diagnostic questions with deliberate misconception traps."
-          }
-        ]
-      };
+  async loadPacksForOrg(organizationCode) {
+    let query = this.client.from("standards_frameworks").select("*, standards_org_adoptions(organization_code)").eq("status", "active");
+    const { data: frameworks, error } = await query;
+    if (error) throw new Error("loadPacksForOrg: " + error.message);
+    const visible = (frameworks ?? []).filter((f) => {
+      const own = f.organization_code && organizationCode && f.organization_code === organizationCode;
+      const global = !f.organization_code;
+      const adopted = organizationCode && (f.standards_org_adoptions ?? []).some((a) => a.organization_code === organizationCode);
+      return global || own || adopted;
+    });
+    if (visible.length === 0) return [];
+    const ids = visible.map((f) => f.id);
+    const [{ data: statements, error: stErr }, { data: mappings, error: mpErr }, { data: overrides, error: ovErr }] = await Promise.all([
+      this.client.from("standards_statements").select("*").in("framework_id", ids),
+      this.client.from("standards_mappings").select("*").in("framework_id", ids),
+      this.client.from("standards_mapping_overrides").select("*").in("framework_id", ids)
+    ]);
+    if (stErr) throw new Error("loadPacksForOrg statements: " + stErr.message);
+    const overridesByFw = /* @__PURE__ */ new Map();
+    for (const o of overrides ?? []) {
+      const list = overridesByFw.get(o.framework_id) ?? [];
+      list.push(o);
+      overridesByFw.set(o.framework_id, list);
     }
-    let questionsWithFullExplanations = 0;
-    for (let i = 0; i < questions.length; i++) {
-      const q = questions[i];
-      const qId = q.id || `Q${i + 1}`;
-      const options = q.options || [];
-      if (options.length < 4) {
-        score -= 15;
-        findings.push({
-          id: `misconception_few_options_${qId}`,
-          dimension: "MISCONCEPTION_RIGOR",
-          severity: "MAJOR",
-          title: `Insufficient Distractors in ${qId}`,
-          description: `Question ${qId} has only ${options.length} options. Standard diagnostic rigor requires 4 plausible choices (1 key + 3 diagnostic distractors).`,
-          remediationAdvice: "Provide 4 full options (A, B, C, D) representing distinct cognitive states.",
-          affectedElement: qId
-        });
-      }
-      const correctCount = options.filter((o) => o.isCorrect).length;
-      if (correctCount !== 1) {
-        score -= 25;
-        findings.push({
-          id: `misconception_invalid_correct_count_${qId}`,
-          dimension: "MISCONCEPTION_RIGOR",
-          severity: "CRITICAL",
-          title: `Key Assignment Error in ${qId}`,
-          description: `Question ${qId} has ${correctCount} correct options (must have exactly 1 true answer).`,
-          remediationAdvice: "Set `isCorrect: true` on exactly one option and `isCorrect: false` on all distractors.",
-          affectedElement: qId
-        });
-      }
-      let missingExplanation = false;
-      for (const opt of options) {
-        const text = (opt.text || "").trim();
-        const explanation = (opt.explanation || "").trim();
-        if (LAZY_DISTRACTOR_PATTERNS.some((p) => p.test(text))) {
-          score -= 10;
-          findings.push({
-            id: `misconception_lazy_distractor_${qId}_${opt.id}`,
-            dimension: "MISCONCEPTION_RIGOR",
-            severity: "MAJOR",
-            title: `Low-Utility Distractor in ${qId} (${opt.id})`,
-            description: `Option "${text}" is a generic/throwaway distractor ("All/None of the above" or "No effect") that does not diagnose student cognitive models.`,
-            remediationAdvice: "Replace with an authentic student misconception (e.g. inverted logic, missing pullup, off-by-one boundary, unit confusion).",
-            affectedElement: `${qId}.${opt.id}`
-          });
-        }
-        if (!explanation || explanation.length < 20) {
-          missingExplanation = true;
-        }
-      }
-      if (missingExplanation) {
-        score -= 10;
-        findings.push({
-          id: `misconception_shallow_explanation_${qId}`,
-          dimension: "MISCONCEPTION_RIGOR",
-          severity: "MAJOR",
-          title: `Shallow Distractor Explanations in ${qId}`,
-          description: `Question ${qId} lacks detailed pedagogical explanations for all options. Students and teachers cannot diagnose root causes without option-level rationale.`,
-          remediationAdvice: "For EVERY option (A, B, C, D), explicitly write why the choice is correct or what mental misconception it represents.",
-          affectedElement: qId
-        });
-      } else {
-        questionsWithFullExplanations++;
+    return visible.map((f) => {
+      const stmts = (statements ?? []).filter((s) => s.framework_id === f.id).map((s) => ({
+        id: s.statement_id,
+        parentId: s.parent_statement_id ?? void 0,
+        gradeBand: [s.grade_min, s.grade_max],
+        texts: s.texts,
+        classifications: s.classifications ?? [],
+        bloomHint: s.bloom_hint ?? void 0,
+        keywords: s.keywords ?? [],
+        sourceRef: s.source_ref ?? void 0,
+        provenance: s.provenance ?? { method: "imported" }
+      }));
+      const ov = overridesByFw.get(f.id) ?? [];
+      const retired = new Set(ov.filter((o) => o.kind === "retired").map((o) => o.statement_id + "|" + o.target_ref));
+      const embedded = (mappings ?? []).filter((m) => m.framework_id === f.id).map((m) => ({
+        statementId: m.statement_id,
+        targetRef: m.target_ref,
+        kind: m.kind,
+        confidence: Number(m.confidence),
+        provenance: m.provenance ?? { method: "imported" }
+      }));
+      const overlay = ov.filter((o) => o.kind !== "retired").map((o) => ({
+        statementId: o.statement_id,
+        targetRef: o.target_ref,
+        kind: o.kind,
+        confidence: Number(o.confidence),
+        provenance: { method: "human", reviewedBy: o.created_by ?? "overlay", note: o.note ?? void 0 }
+      }));
+      const bridge = /* @__PURE__ */ new Map();
+      for (const m of embedded) bridge.set(m.statementId + "|" + m.targetRef, m);
+      for (const m of overlay) bridge.set(m.statementId + "|" + m.targetRef, m);
+      const finalMappings = [...bridge.values()].filter((m) => !retired.has(m.statementId + "|" + m.targetRef));
+      const hydrated = FrameworkPackSchema.safeParse({
+        manifest: {
+          id: f.pack_id,
+          name: f.name,
+          specVersion: f.spec_version || "1.0",
+          contentVersion: f.content_version,
+          subject: f.subject,
+          languages: f.languages,
+          gradeModel: f.grade_model,
+          provenance: f.provenance,
+          trust: f.trust
+        },
+        statements: stmts,
+        mappings: finalMappings
+      });
+      if (!hydrated.success) {
+        throw new Error('loadPacksForOrg: hydrated pack "' + f.pack_id + '" failed schema: ' + hydrated.error.issues[0]?.message);
       }
-    }
-    if (questionsWithFullExplanations === questions.length && questions.length >= 3) {
-      strengths.push("All quiz questions feature rigorous 4-option breakdown with comprehensive misconception analysis.");
-    }
-    score = Math.max(0, Math.min(100, score));
-    return {
-      score,
-      weight: 0.2,
-      passed: score >= 75 && !findings.some((f) => f.severity === "CRITICAL"),
-      strengths,
-      findings
-    };
+      return { ...hydrated.data, dbId: f.id, status: f.status, organizationCode: f.organization_code ?? null };
+    });
   }
 };
 
@@ -17190,6 +16623,8 @@ exports.CurriculumPlanSchema = CurriculumPlanSchema;
 exports.CurriculumQualityReportSchema = CurriculumQualityReportSchema;
 exports.DEFAULT_ENABLED_PROVIDERS = DEFAULT_ENABLED_PROVIDERS;
 exports.DEFAULT_GATE_SETTINGS = DEFAULT_GATE_SETTINGS;
+exports.DEFAULT_STREAM_IDLE_MS = DEFAULT_STREAM_IDLE_MS;
+exports.DEFAULT_STREAM_TOTAL_MS = DEFAULT_STREAM_TOTAL_MS;
 exports.DependencyEdgeSchema = DependencyEdgeSchema;
 exports.DepthAssignmentSchema = DepthAssignmentSchema;
 exports.DepthLevelSchema = DepthLevelSchema;
@@ -17234,6 +16669,7 @@ exports.HandoutSectionSchema = HandoutSectionSchema;
 exports.InstructionSectionSchema = InstructionSectionSchema;
 exports.InstructionStepSchema = InstructionStepSchema;
 exports.JudgeCriterionSchema = JudgeCriterionSchema;
+exports.LAYER_TOTAL_BUDGET_MS = LAYER_TOTAL_BUDGET_MS;
 exports.LESSON_PLAN_TEMPLATE = LESSON_PLAN_TEMPLATE;
 exports.LLMJudgeEngine = LLMJudgeEngine;
 exports.LabTierTaskSchema = LabTierTaskSchema;
@@ -17329,8 +16765,6 @@ exports.WorksheetSchema = WorksheetSchema;
 exports.activityTools = activityTools;
 exports.analystTools = analystTools;
 exports.analyzeProjectCreationIntent = analyzeProjectCreationIntent;
-exports.approvalHookToken = approvalHookToken;
-exports.approvalPayloadSchema = approvalPayloadSchema;
 exports.assertAcyclic = assertAcyclic;
 exports.assessorTools = assessorTools;
 exports.auditCurriculumQualityFlow = auditCurriculumQualityFlow;
@@ -17363,6 +16797,7 @@ exports.contentTools = contentTools;
 exports.convertRoadmapToFoundationSot = convertRoadmapToFoundationSot;
 exports.createAiInferenceError = createAiInferenceError;
 exports.createCurriculumStorage = createCurriculumStorage;
+exports.createStreamAbortSignal = createStreamAbortSignal;
 exports.curateMediaLedger = curateMediaLedger;
 exports.designerTools = designerTools;
 exports.detectProjectPedagogy = detectProjectPedagogy;
@@ -17370,47 +16805,34 @@ exports.ensureExpositionForLesson = ensureExpositionForLesson;
 exports.ensureKnowledgeExposition = ensureKnowledgeExposition;
 exports.evaluateStandardsCoverage = evaluateStandardsCoverage;
 exports.executeCurriculumCommand = executeCurriculumCommand;
-exports.executeSingleArtifactStep = executeSingleArtifactStep;
 exports.exportAllProjectQuizzes = exportAllProjectQuizzes;
 exports.expositionCacheKey = expositionCacheKey;
 exports.extractScopeSequenceRows = extractScopeSequenceRows;
 exports.extractSessionSlice = extractSessionSlice;
+exports.extractStreamChunk = extractStreamChunk;
 exports.extractThoughtAndContent = extractThoughtAndContent;
 exports.formatQuizzesToCsv = formatQuizzesToCsv;
 exports.fulfillMediaLedger = fulfillMediaLedger;
 exports.gateModeFor = gateModeFor;
 exports.generateActivityFlow = generateActivityFlow;
-exports.generateActivityStep = generateActivityStep;
 exports.generateCodeLabFlow = generateCodeLabFlow;
-exports.generateCodeLabStep = generateCodeLabStep;
 exports.generateDiagnosticQuizFlow = generateDiagnosticQuizFlow;
-exports.generateDiagnosticQuizStep = generateDiagnosticQuizStep;
 exports.generateEducationalImage = generateEducationalImage;
 exports.generateExtensionFlow = generateExtensionFlow;
-exports.generateExtensionStep = generateExtensionStep;
 exports.generateHandoutFlow = generateHandoutFlow;
-exports.generateHandoutStep = generateHandoutStep;
 exports.generateLessonMasterFlow = generateLessonMasterFlow;
-exports.generateMasterLessonStep = generateMasterLessonStep;
 exports.generateMilestoneCurriculumBundle = generateMilestoneCurriculumBundle;
-exports.generateMilestoneWorkflow = generateMilestoneWorkflow;
 exports.generatePhase1SotArtifacts = generatePhase1SotArtifacts;
 exports.generatePhase2SotArtifacts = generatePhase2SotArtifacts;
 exports.generateProjectInstruction = generateProjectInstruction;
 exports.generateProjectInstructionFlow = generateProjectInstructionFlow;
 exports.generateRoadmapCurriculum = generateRoadmapCurriculum;
-exports.generateRoadmapWorkflow = generateRoadmapWorkflow;
 exports.generateSelfLabFlow = generateSelfLabFlow;
-exports.generateSelfLabStep = generateSelfLabStep;
 exports.generateSelfPacedBundle = generateSelfPacedBundle;
 exports.generateSingleArtifact = generateSingleArtifact;
-exports.generateSingleArtifactWorkflow = generateSingleArtifactWorkflow;
 exports.generateSlidesFlow = generateSlidesFlow;
-exports.generateSlidesStep = generateSlidesStep;
 exports.generateTeacherGuideFlow = generateTeacherGuideFlow;
-exports.generateTeacherGuideStep = generateTeacherGuideStep;
 exports.generateWorksheetFlow = generateWorksheetFlow;
-exports.generateWorksheetStep = generateWorksheetStep;
 exports.getAIModel = getAIModel;
 exports.getArtifactMetadata = getArtifactMetadata;
 exports.getDesignatedFallbackChain = getDesignatedFallbackChain;
@@ -17431,9 +16853,6 @@ exports.isExpositionFresh = isExpositionFresh;
 exports.isModelAllowed = isModelAllowed;
 exports.isProviderEnabled = isProviderEnabled;
 exports.isTranslationDue = isTranslationDue;
-exports.judgeMasterLessonStep = judgeMasterLessonStep;
-exports.judgeSatelliteStep = judgeSatelliteStep;
-exports.lessonApprovalHook = lessonApprovalHook;
 exports.lintAndSanitizeArtifact = lintAndSanitizeArtifact;
 exports.lintCurriculumFramework = lintCurriculumFramework;
 exports.lintFrameworkPack = lintFrameworkPack;
@@ -17447,21 +16866,18 @@ exports.parseRoadmapJsonToProjectPayload = parseRoadmapJsonToProjectPayload;
 exports.produceBatchLessons = produceBatchLessons;
 exports.produceSingleLesson = produceSingleLesson;
 exports.publishToGitHub = publishToGitHub;
-exports.publishToGitStep = publishToGitStep;
 exports.publishToSupabase = publishToSupabase;
-exports.publishToSupabaseStep = publishToSupabaseStep;
 exports.rankGenCandidates = rankGenCandidates;
 exports.renderFrameworkFromPlan = renderFrameworkFromPlan;
 exports.renderMediaPlaceholder = renderMediaPlaceholder;
-exports.repairMasterLessonStep = repairMasterLessonStep;
 exports.researcherTools = researcherTools;
 exports.resolveGateSettings = resolveGateSettings;
 exports.resolveStandardsPacks = resolveStandardsPacks;
+exports.resolveStreamBudget = resolveStreamBudget;
 exports.resolveTranslationTargets = resolveTranslationTargets;
 exports.reviewerTools = reviewerTools;
 exports.runCurriculumAIInference = runCurriculumAIInference;
 exports.safeParseJson = safeParseJson;
-exports.saveMilestoneToWorkspaceStep = saveMilestoneToWorkspaceStep;
 exports.searchEducationalImages = searchEducationalImages;
 exports.searchEducationalVideos = searchEducationalVideos;
 exports.selectStatementsForLesson = selectStatementsForLesson;
@@ -17488,6 +16904,5 @@ exports.validateFrameworkPack = validateFrameworkPack;
 exports.validateMarkdownTables = validateMarkdownTables;
 exports.validateMermaidSyntax = validateMermaidSyntax;
 exports.withAutoRepair = withAutoRepair;
-exports.withRateLimitBackoff = withRateLimitBackoff;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map