@thanh01.pmt/curriculum-kit 1.4.0 → 1.4.2

package/dist/index.cjs

@@ -1312,7 +1312,9 @@ var LessonPlanSchema = zod.z.object({
     name: zod.z.string().optional().default(""),
     description: zod.z.string(),
     bloomLevel: zod.z.string().default("understand"),
-    successCriteria: zod.z.string().optional().default("")
+    successCriteria: zod.z.string().optional().default(""),
+    standardRefs: zod.z.array(zod.z.string()).optional(),
+    conceptRefs: zod.z.array(zod.z.string()).optional()
   })).default([]),
   prerequisites: zod.z.string().optional().default(""),
   materialsSummary: zod.z.string().optional().default(""),
@@ -9827,7 +9829,6 @@ var DEFAULT_KX_PRIORITIES = [
 ];
 function buildSectionAwareExcerpt(markdown, opts = {}) {
   const budget = opts.budget ?? 12e3;
-  const minContentChars = opts.minContentChars ?? 400;
   const issues = [];
   const source = (markdown || "").trim();
   if (!source) {
@@ -9840,9 +9841,11 @@ function buildSectionAwareExcerpt(markdown, opts = {}) {
       tokenEstimate: 0
     };
   }
+  const minContentChars = opts.minContentChars !== void 0 ? opts.minContentChars : Math.min(400, source.length);
   const slcMap = normalizeSlcContract(opts.sectionLanguageContract);
-  const sections = parseMarkdownSections(source, slcMap, opts.artifactType);
-  const metaBlock = buildMetaBlock(source);
+  const effectiveArtifactType = opts.artifactType || deriveArtifactTypeFromFileName(opts.fileName);
+  const sections = parseMarkdownSections(source, slcMap, effectiveArtifactType);
+  const metaBlock = buildMetaBlock(source, effectiveArtifactType);
   if (sections.length === 0) {
     issues.push("parse:no-sections");
     const excerpt2 = truncateByBudget(source, budget);
@@ -9858,44 +9861,74 @@ function buildSectionAwareExcerpt(markdown, opts = {}) {
     };
   }
   const byCanonical = /* @__PURE__ */ new Map();
+  const byCleanTitle = /* @__PURE__ */ new Map();
   const unmatched = [];
   for (const s of sections) {
     if (s.canonicalKey && !byCanonical.has(s.canonicalKey)) {
       byCanonical.set(s.canonicalKey, s);
-    } else {
+    }
+    const norm = normalizeHeading(s.cleanTitle);
+    if (!byCleanTitle.has(norm)) {
+      byCleanTitle.set(norm, s);
+    }
+    if (!s.canonicalKey) {
       unmatched.push(s);
     }
   }
   const priorities = opts.priorities ?? DEFAULT_LESSON_PRIORITIES;
   const includedSections = [];
   const blocks = [];
-  let used = 0;
+  const initialOverhead = metaBlock ? metaBlock.length + 2 : 0;
+  let used = initialOverhead;
   const tryAdd = (heading, body, key) => {
     const trimmedBody = body.trim();
     if (!trimmedBody) return false;
     const block = `## ${heading}
 
 ${trimmedBody}`;
-    if (used + block.length > budget && used > 0) return false;
-    blocks.push(block);
-    used += block.length;
-    includedSections.push(key);
-    return true;
+    if (used + block.length <= budget) {
+      blocks.push(block);
+      used += block.length;
+      includedSections.push(key);
+      return true;
+    }
+    if (includedSections.length === 0 && budget >= minContentChars) {
+      const headingOverhead = `## ${heading}
+
+`.length;
+      const remaining = budget - used;
+      if (remaining > headingOverhead + 50) {
+        const allowedBody = remaining - headingOverhead;
+        const truncated = truncateByBudget(trimmedBody, allowedBody).trim();
+        if (truncated.length > 0) {
+          const partialBlock = `## ${heading}
+
+${truncated}`;
+          blocks.push(partialBlock);
+          used += partialBlock.length;
+          includedSections.push(key);
+          issues.push(`section:truncated:${key}`);
+          return true;
+        }
+      }
+    }
+    return false;
   };
   blocks.push(metaBlock);
   let sectionAware = false;
   for (const key of priorities) {
-    const sec = byCanonical.get(key);
+    const sec = byCanonical.get(key) || byCleanTitle.get(normalizeHeading(key));
     if (!sec) continue;
     sectionAware = true;
     if (!tryAdd(sec.cleanTitle, sec.body, key)) break;
   }
   for (const [key, sec] of byCanonical) {
-    if (includedSections.includes(key)) continue;
+    if (includedSections.includes(key) || includedSections.includes(sec.cleanTitle)) continue;
     if (used >= budget) break;
     if (!tryAdd(sec.cleanTitle, sec.body, key)) break;
   }
   for (const sec of unmatched) {
+    if (includedSections.includes(sec.cleanTitle)) continue;
     if (used >= budget) break;
     if (!tryAdd(sec.cleanTitle, sec.body, sec.cleanTitle)) break;
   }
@@ -9903,17 +9936,16 @@ ${trimmedBody}`;
     issues.push("parse:no-canonical-resolution");
   }
   if (priorities.length > 0 && !priorities.some((k) => includedSections.includes(k))) {
-    issues.push("parse:no-priority-resolution");
+    issues.push(sections.length === 0 ? "parse:no-sections" : "parse:no-priority-resolution");
   }
   let excerpt = blocks.join("\n\n");
   if (excerpt.length > budget) {
     excerpt = truncateByBudget(excerpt, budget);
   }
-  const effectiveMinChars = Math.min(minContentChars, source.length);
-  if (excerpt.length - metaBlock.length < effectiveMinChars) {
+  if (excerpt.length - metaBlock.length < minContentChars) {
     issues.push("content:insufficient");
   }
-  const verified = !issues.includes("parse:no-priority-resolution") && !issues.includes("parse:no-canonical-resolution") && excerpt.length - metaBlock.length >= effectiveMinChars;
+  const verified = !issues.includes("parse:no-priority-resolution") && !issues.includes("parse:no-canonical-resolution") && excerpt.length - metaBlock.length >= minContentChars;
   return {
     excerpt,
     verified,
@@ -9973,7 +10005,7 @@ function parseMarkdownSections(markdown, slcMap, artifactType) {
     }
   }
   const flush = () => {
-    if (!currentHeading && currentBody.length === 0) return;
+    if (!currentHeading) return;
     const cleanTitle = currentHeading.replace(/^#{1,4}\s+/, "").trim();
     const norm = normalizeHeading(cleanTitle);
     const canonicalKey = reverseMap.get(norm) || findCanonicalFuzzy(norm);
@@ -10033,7 +10065,7 @@ function truncateByBudget(source, budget) {
   if (fenceCount % 2 === 1) cut += "\n```";
   return cut;
 }
-function buildMetaBlock(source) {
+function buildMetaBlock(source, artifactType) {
   const fm = source.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
   const pick = (key) => {
     if (!fm) return "";
@@ -10042,9 +10074,17 @@ function buildMetaBlock(source) {
   };
   const id = pick("id");
   const title = pick("title");
-  const type = pick("type");
+  const type = pick("type") || artifactType || "";
   return `<!-- SOURCE: ${type || "ARTIFACT"} | ${id || "unknown"}${title ? ` \u2014 ${title}` : ""} (section-aware excerpt; canonical knowledge, do not contradict) -->`;
 }
+function deriveArtifactTypeFromFileName(fileName) {
+  if (!fileName) return void 0;
+  const base = fileName.replace(/\.md$/i, "");
+  const multiWord = base.match(/^(KNOWLEDGE_EXPOSITION|SECTION_LANGUAGE_CONTRACT|CONTENT_STYLE_GUIDE|CURRICULUM_FRAMEWORK|LEARNER_PROFILE|PROJECT_BRIEF|REFERENCE_PACK|CURRICULUM_PLAN)/i);
+  if (multiWord) return multiWord[1].toUpperCase();
+  const token = base.match(/^([A-Z][A-Z0-9_]*?)(?=_|$)/);
+  return token ? token[1] : void 0;
+}
 
 // src/services/knowledgeExpositionService.ts
 var EXPOSITION_REL = (lessonCode) => "_sot/expositions/" + lessonCode + ".md";
@@ -10948,6 +10988,120 @@ function buildStandardsContext(input) {
   const selected = selectStatementsForLesson(input);
   return { block: buildStandardsContextBlock(selected, { language: input.language }), selected };
 }
+
+// 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);
+    }
+  }
+  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);
+      }
+    }
+    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`]
+        });
+      }
+    }
+  }
+  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 BloomHintSchema = zod.z.object({
   process: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]).describe("Cognitive process axis"),
   knowledge: zod.z.enum(["FACTUAL", "CONCEPTUAL", "PROCEDURAL", "METACOGNITIVE"]).optional().describe("Knowledge dimension axis (optional \u2014 most source standards do not tag it)")
@@ -11383,9 +11537,170 @@ var csta_k12_2017_default = {
   ]
 };
 
+// src/standards/data/acm-ieee-cs2023.json
+var acm_ieee_cs2023_default = {
+  manifest: {
+    id: "acm-ieee-cs2023",
+    name: "ACM/IEEE-CS/AAAI Computer Science Curricula 2023 (CS2023)",
+    specVersion: "1.0",
+    contentVersion: "2023.1",
+    subject: "computing",
+    languages: ["en"],
+    gradeModel: {
+      type: "grades",
+      range: [9, 16]
+    },
+    provenance: {
+      sourceRef: "ACM/IEEE-CS/AAAI Computer Science Curricula 2023 - cs2023.org",
+      sourceUrl: "https://cs2023.org",
+      license: "ACM / IEEE Computer Society (cited verbatim for curriculum alignment)",
+      importedBy: "platform",
+      importedAt: "2026-09-11T00:00:00.000Z"
+    },
+    trust: "verified"
+  },
+  statements: [
+    {
+      id: "CS2023-SDF-01",
+      gradeBand: [9, 14],
+      texts: {
+        en: "Design, implement, test, and debug programs using basic computation, standard conditional and iterative structures, and functions."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Development Fundamentals (SDF)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["algorithms", "control structures", "functions", "variables", "debugging", "programming", "implementation"],
+      sourceRef: "CS2023, Software Development Fundamentals, Program Construction",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SDF-02",
+      gradeBand: [9, 14],
+      texts: {
+        en: "Apply fundamental data structures (arrays, lists, stacks, queues, hash maps) to represent collections of data and solve algorithmic problems."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Development Fundamentals (SDF)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["data structures", "arrays", "lists", "hash maps", "collections", "stacks", "queues"],
+      sourceRef: "CS2023, Software Development Fundamentals, Fundamental Data Structures",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-AL-01",
+      gradeBand: [10, 16],
+      texts: {
+        en: "Analyze and compare the time and space complexity of fundamental algorithms using asymptotic notation (Big-O)."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Algorithms and Complexity (AL)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Analyze" },
+      keywords: ["complexity", "big-o", "efficiency", "sorting", "searching", "asymptotic", "runtime"],
+      sourceRef: "CS2023, Algorithms and Complexity, Basic Analysis",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SE-01",
+      gradeBand: [9, 16],
+      texts: {
+        en: "Decompose complex problems into modular software components applying principles of abstraction, encapsulation, and separation of concerns."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Engineering (SE)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Create" },
+      keywords: ["modularity", "abstraction", "software design", "refactoring", "encapsulation", "architecture"],
+      sourceRef: "CS2023, Software Engineering, Software Design and Architecture",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SEC-01",
+      gradeBand: [9, 16],
+      texts: {
+        en: "Incorporate defensive programming and fundamental cybersecurity principles (least privilege, input validation, secure data handling) into software development."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Security (SEC)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["security", "defensive programming", "input validation", "cybersecurity", "vulnerabilities"],
+      sourceRef: "CS2023, Security, Secure Software Development",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-AI-01",
+      gradeBand: [10, 16],
+      texts: {
+        en: "Formulate machine learning tasks, prepare training and evaluation datasets, and evaluate model performance using standard metrics."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Artificial Intelligence (AI)" },
+        { axis: "Core Tier", value: "Tier-2 Core" }
+      ],
+      bloomHint: { process: "Evaluate" },
+      keywords: ["artificial intelligence", "machine learning", "dataset", "evaluation", "model", "accuracy"],
+      sourceRef: "CS2023, Artificial Intelligence, Machine Learning Fundamentals",
+      provenance: { method: "source_official" }
+    }
+  ],
+  mappings: [
+    {
+      statementId: "CS2023-SDF-01",
+      targetRef: "ontora:PROGRAM_CONSTRUCTION",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SDF-02",
+      targetRef: "ontora:DATA_STRUCTURES",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-AL-01",
+      targetRef: "ontora:ALGORITHM_COMPLEXITY",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SE-01",
+      targetRef: "ontora:SOFTWARE_ARCHITECTURE",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SEC-01",
+      targetRef: "ontora:DEFENSIVE_PROGRAMMING",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-AI-01",
+      targetRef: "ontora:MACHINE_LEARNING",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    }
+  ]
+};
+
 // src/standards/bundledPacks.ts
 var BUNDLED_PACK_RECORDS = {
-  "csta-k12-2017": csta_k12_2017_default
+  "csta-k12-2017": csta_k12_2017_default,
+  "acm-ieee-cs2023": acm_ieee_cs2023_default
 };
 var BUNDLED_STANDARDS_PACK_IDS = Object.keys(BUNDLED_PACK_RECORDS).sort();
 var parsedPackCache = /* @__PURE__ */ new Map();
@@ -11412,6 +11727,36 @@ function resolveStandardsPacks(packIds) {
   }
   return packs;
 }
+function findStandardStatement(statementIdOrRef) {
+  if (!statementIdOrRef) return null;
+  const [packPrefix, ...rest] = statementIdOrRef.split(":");
+  const targetId = rest.length > 0 ? rest.join(":") : statementIdOrRef;
+  const packs = resolveStandardsPacks(BUNDLED_STANDARDS_PACK_IDS);
+  for (const pack of packs) {
+    if (rest.length > 0 && pack.manifest.id !== packPrefix) continue;
+    const stmt = pack.statements.find((s) => s.id.toLowerCase() === targetId.toLowerCase());
+    if (stmt) {
+      const description = stmt.texts["en"] || Object.values(stmt.texts)[0] || "";
+      const category = stmt.classifications && stmt.classifications.length > 0 ? stmt.classifications.map((c) => c.value).join(", ") : void 0;
+      const gradeBand = Array.isArray(stmt.gradeBand) ? stmt.gradeBand[0] === stmt.gradeBand[1] ? String(stmt.gradeBand[0]) : `${stmt.gradeBand[0]}-${stmt.gradeBand[1]}` : void 0;
+      return {
+        packId: pack.manifest.id,
+        packTitle: pack.manifest.name,
+        statementId: stmt.id,
+        description,
+        category,
+        gradeBand
+      };
+    }
+  }
+  return null;
+}
+var STANDARD_REF_REGEX = /\b(?:(?:csta-k12-2017|acm-ieee-cs2023):)?(?:[1-3][A-B]?-[A-Z]{2}-\d{2}|CS2023-[A-Z0-9_-]+)\b/gi;
+function extractStandardRefs(text) {
+  if (!text) return [];
+  const matches = Array.from(text.matchAll(STANDARD_REF_REGEX)).map((m) => m[0]);
+  return Array.from(new Set(matches));
+}
 
 // src/services/languageDirective.ts
 function resolveTargetLanguageCode(language) {
@@ -11723,7 +12068,7 @@ type: "LESSON_EDP"
 - **Estimated Duration:** 90 minutes
 - **Project Objective:** [Complete engineering system or functional deliverable students build]
 - **Materials & Equipment:** [Detailed hardware, software libraries, and workstation tools]
-- **Learning Objectives Table:** (LO1, LO2 mapped with EDP Bloom level, Student Evidence, and Success Criteria)
+- **Learning Objectives Table:** (LO1, LO2 mapped with EDP Bloom level, Student Evidence, Success Criteria, and matching Standard ID from [STANDARDS STATEMENTS] if present, e.g. "CSTA: 1B-AP-10" or "CS2023-SDF-01")
 
 ### 2. Activity Sequence
 > Activity Contract table with columns: Seq, EDP Phase (Ask, Imagine, Plan, Create, Test & Improve, Share & Evaluate), Activity Type, Actor, Purpose, Student Action, Teacher Move, Output/Evidence, LO, Time, Artifact Contract.
@@ -11773,7 +12118,7 @@ type: "LESSON_GENERAL"
 - **Estimated Duration:** 90 minutes
 - **Materials & Equipment:** [Tools, IDE, workstations, resources]
 - **Keywords / Core Concepts:** [Core domain terminology]
-- **Learning Objectives Table:** (LO1, LO2 with Bloom action verbs, Student Evidence, Success Criteria)
+- **Learning Objectives Table:** (LO1, LO2 with Bloom action verbs, Student Evidence, Success Criteria, and matching Standard ID from [STANDARDS STATEMENTS] if present, e.g. "CSTA: 1B-AP-10" or "CS2023-SDF-01")
 
 ### 2. Activity Sequence
 > Activity Contract table with columns: Seq, Lesson Stage (Warm-up, Core Concepts, Guided Practice, Independent Practice, Wrap-up), Activity Type, Actor, Purpose, Student Action, Teacher Move, Output/Evidence, LO, Time, Artifact Contract.
@@ -11821,7 +12166,7 @@ type: "LESSON_5E"
 - **Estimated Duration:** 90 minutes
 - **Materials & Equipment:** [Tools, IDE, hardware/software specifications]
 - **Keywords / Core Concepts:** [Core domain terminology]
-- **Learning Objectives Table:** (LO1, LO2 with Bloom action verbs, Student Evidence, Success Criteria)
+- **Learning Objectives Table:** (LO1, LO2 with Bloom action verbs, Student Evidence, Success Criteria, and matching Standard ID from [STANDARDS STATEMENTS] if present, e.g. "CSTA: 1B-AP-10" or "CS2023-SDF-01")
 
 ### 2. Activity Sequence
 > Activity Contract table with columns: Seq, 5E Phase (Engage, Explore, Explain, Elaborate, Evaluate), Activity Type, Actor, Purpose, Student Action, Teacher Move, Output/Evidence, LO, Time, Artifact Contract.
@@ -13041,13 +13386,52 @@ ${buildHeadingDirective("EXT", slcMarkdown, targetLang)}`;
       });
     }
   }
+  let standardsCoverage;
+  if (packs.length > 0 && lessonContent) {
+    try {
+      const objectives = parseLessonObjectivesWithStandards(lessonContent, concept, bloomLevel, packs);
+      const activities = parseActivitySequenceLo(lessonContent);
+      const quizContent = await storage.readArtifact(projectId, quizRelPath).catch(() => null);
+      const quizQuestions = quizContent ? parseQuizQuestionsLo(quizContent) : [];
+      const selected = selectStatementsForLesson({
+        packs,
+        gradeBand: options.gradeBand ?? [6, 12],
+        topicText: `${lessonTitle} ${concept}`
+      });
+      const targetStatementIds = new Set(selected.map((s) => s.statement.id.toLowerCase()));
+      for (const lo of objectives) {
+        for (const r of lo.standardRefs || []) {
+          targetStatementIds.add(r.replace(/^[^:]+:/, "").toLowerCase());
+        }
+      }
+      const scopedPacks = packs.map((p) => ({
+        ...p,
+        statements: p.statements.filter((s) => targetStatementIds.has(s.id.toLowerCase()))
+      })).filter((p) => p.statements.length > 0);
+      if (scopedPacks.length > 0) {
+        standardsCoverage = evaluateStandardsCoverage({
+          packs: scopedPacks,
+          objectives,
+          activities,
+          quizQuestions
+        });
+        onProgress?.(
+          "@reviewer",
+          `\u{1F4CA} Standards Coverage Gate: ${standardsCoverage.verdict} (${standardsCoverage.coveragePct}% coverage, ${standardsCoverage.rows.filter((r) => r.status === "COVERED").length}/${standardsCoverage.rows.length} statements covered)`
+        );
+      }
+    } catch (covErr) {
+      console.warn("[lessonProductionService] Failed to evaluate standards coverage:", covErr?.message || covErr);
+    }
+  }
   return {
     lessonId: lessonCode,
     pedagogy,
     producedArtifacts,
     pausedForReview: false,
     contextInjection: lessonInjection && lessonInjection.verified ? expositionInjection || lessonInjection : lessonInjection || expositionInjection,
-    promptChars: commonContext.length
+    promptChars: commonContext.length,
+    standardsCoverage
   };
 }
 function parseLessonObjectives(lessonContent, concept, bloomLevel) {
@@ -13069,6 +13453,65 @@ function parseLessonObjectives(lessonContent, concept, bloomLevel) {
   }
   return objectives.slice(0, 6);
 }
+function parseLessonObjectivesWithStandards(lessonContent, concept, bloomLevel, _packs) {
+  const baseObjectives = parseLessonObjectives(lessonContent, concept, bloomLevel);
+  const lines = lessonContent.split("\n");
+  return baseObjectives.map((lo) => {
+    const refs = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (line.includes(lo.code)) {
+        const found = extractStandardRefs(line);
+        for (const r of found) refs.add(r);
+      }
+    }
+    return {
+      ...lo,
+      standardRefs: refs.size > 0 ? Array.from(refs) : void 0
+    };
+  });
+}
+function parseActivitySequenceLo(lessonContent) {
+  const activities = [];
+  const lines = lessonContent.split("\n");
+  let currentSeq = 1;
+  for (const line of lines) {
+    const matchActivity = line.match(/(?:Hoạt động|Activity|Phase|Giai đoạn)\s*(\d+)/i);
+    const loMatches = Array.from(line.matchAll(/\b(LO\d+)\b/gi)).map((m) => m[1].toUpperCase());
+    if (matchActivity && loMatches.length > 0) {
+      activities.push({
+        seq: parseInt(matchActivity[1], 10),
+        lo: Array.from(new Set(loMatches))
+      });
+    } else if (loMatches.length > 0 && line.trim().startsWith("|")) {
+      activities.push({
+        seq: currentSeq++,
+        lo: Array.from(new Set(loMatches))
+      });
+    }
+  }
+  if (activities.length === 0) {
+    const allLos = Array.from(lessonContent.matchAll(/\b(LO\d+)\b/gi)).map((m) => m[1].toUpperCase());
+    if (allLos.length > 0) {
+      activities.push({ seq: 1, lo: Array.from(new Set(allLos)) });
+    }
+  }
+  return activities;
+}
+function parseQuizQuestionsLo(quizContent) {
+  const questions = [];
+  const lines = quizContent.split("\n");
+  for (const line of lines) {
+    const loMatch = line.match(/\b(LO\d+)\b/i);
+    const aoMatch = line.match(/\b(AO\d+)\b/i);
+    if (loMatch || aoMatch) {
+      questions.push({
+        alignedLO: loMatch ? loMatch[1].toUpperCase() : void 0,
+        alignedAO: aoMatch ? aoMatch[1].toUpperCase() : void 0
+      });
+    }
+  }
+  return questions;
+}
 async function judgeSatelliteArtifact(ctx) {
   const { storage, projectId, lessonCode, sat, content } = ctx;
   try {
@@ -16793,120 +17236,6 @@ var MisconceptionEvaluator = class {
     };
   }
 };
-
-// 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);
-    }
-  }
-  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);
-      }
-    }
-    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`]
-        });
-      }
-    }
-  }
-  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 = {}) {
@@ -17719,6 +18048,7 @@ exports.SELF_LAB_TEMPLATE = SELF_LAB_TEMPLATE;
 exports.SLIDE_CANONICAL_METHODOLOGY = SLIDE_CANONICAL_METHODOLOGY;
 exports.SLIDE_LAYOUT_PRESETS = SLIDE_LAYOUT_PRESETS;
 exports.SLIDE_TEMPLATE = SLIDE_TEMPLATE;
+exports.STANDARD_REF_REGEX = STANDARD_REF_REGEX;
 exports.STANDARD_SOT_FILES = STANDARD_SOT_FILES;
 exports.STATION_ROTATION_TEMPLATE = STATION_ROTATION_TEMPLATE;
 exports.ScaffoldDecisionEntrySchema = ScaffoldDecisionEntrySchema;
@@ -17817,8 +18147,10 @@ exports.expositionCacheKey = expositionCacheKey;
 exports.extractScopeSequenceRows = extractScopeSequenceRows;
 exports.extractSectionHeadingsFromSLC = extractSectionHeadingsFromSLC;
 exports.extractSessionSlice = extractSessionSlice;
+exports.extractStandardRefs = extractStandardRefs;
 exports.extractStreamChunk = extractStreamChunk;
 exports.extractThoughtAndContent = extractThoughtAndContent;
+exports.findStandardStatement = findStandardStatement;
 exports.formatQuizzesToCsv = formatQuizzesToCsv;
 exports.fulfillMediaLedger = fulfillMediaLedger;
 exports.gateModeFor = gateModeFor;