@thanh01.pmt/domain-kit 0.1.0 → 0.2.1

package/dist/graph/index.cjs

@@ -25,8 +25,8 @@ function resolveProviderChain(config) {
   }
   push("legacy", process.env.LLM_BASE_URL || process.env.OPENAI_BASE_URL || "", process.env.LLM_API_KEY || process.env.OPENAI_API_KEY || "", process.env.LLM_MODEL || process.env.LLM_TIER_FAST || "");
   push("dashscope", process.env.DASHSCOPE_BASE_URL || process.env.ALIBABA_BASE_URL || "", process.env.DASHSCOPE_API_KEY || process.env.ALIBABA_API_KEY || "", process.env.DASHSCOPE_MODEL || process.env.DEFAULT_AI_MODEL || "");
-  push("nvidia", "https://integrate.api.nvidia.com/v1", process.env.NVIDIA_API_KEY || "", process.env.NVIDIA_MODEL || "nvidia/nemotron-3-ultra-550b-a55b");
-  push("openrouter", "https://openrouter.ai/api/v1", process.env.OPENROUTER_API_KEY || "", process.env.OPENROUTER_MODEL || "nvidia/nemotron-3-ultra-550b-a55b");
+  push("nvidia", "https://integrate.api.nvidia.com/v1", process.env.NVIDIA_API_KEY || "", process.env.NVIDIA_MODEL || "nvidia/nemotron-3-ultra-550b-a55b:free");
+  push("openrouter", "https://openrouter.ai/api/v1", process.env.OPENROUTER_API_KEY || "", process.env.OPENROUTER_MODEL || "nvidia/nemotron-3-ultra-550b-a55b:free");
   if (process.env.OPENROUTER_MODEL) {
     const or = chain.find((c) => c.label === "openrouter");
     if (or) {
@@ -968,6 +968,345 @@ var ULO_CODE_RE = /^ULO-[A-Z][A-Z0-9_]*-\d{2}$/;
 var CIO_CODE_RE = /^CIO-[A-Z][A-Z0-9_]*-\d{2}-[A-Z][A-Z0-9_]*$/;
 var SIO_CODE_RE = /^SIO-[A-Z0-9]+-[A-Z][A-Z0-9_]*-\d{2}$/;
 
+// src/parsers/syllabusParser.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "and",
+  "the",
+  "for",
+  "with",
+  "from",
+  "that",
+  "this",
+  "into",
+  "when",
+  "while",
+  "using",
+  "their",
+  "your",
+  "each",
+  "how",
+  "why",
+  "what",
+  "between",
+  "through",
+  "about",
+  "trong",
+  "nhung",
+  "cac",
+  "cua",
+  "cho",
+  "voi",
+  "duoc",
+  "khong",
+  "theo",
+  "tren",
+  "duoi",
+  "va",
+  "hoac",
+  "thi",
+  "la",
+  "nhu"
+]);
+function extractTokens(text) {
+  const words = text.toLowerCase().replace(/[^a-z0-9à-ỹ\s-]/gi, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+  return [...new Set(words)];
+}
+function extractGradeBand(text) {
+  const gbMatch = text.match(/(?:grade\s*band|độ\s*tuổi|lớp)\s*[:=]?\s*(?:lớp\s*)?(\d{1,2})\s*(?:-|đến|to)\s*(?:lớp\s*)?(\d{1,2})/i);
+  if (gbMatch && gbMatch[1] && gbMatch[2]) {
+    const min = parseInt(gbMatch[1], 10);
+    const max = parseInt(gbMatch[2], 10);
+    return [Math.min(min, max), Math.max(min, max)];
+  }
+  return void 0;
+}
+function extractDomain(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("computer science") || lower.includes("l\u1EADp tr\xECnh") || lower.includes("algorithm") || lower.includes("software")) return "software";
+  if (lower.includes("to\xE1n") || lower.includes("geometry") || lower.includes("algebra") || lower.includes("h\xECnh h\u1ECDc") || lower.includes("mathematics")) return "math";
+  if (lower.includes("v\u1EADt l\xFD") || lower.includes("h\xF3a h\u1ECDc") || lower.includes("sinh h\u1ECDc") || lower.includes("physics") || lower.includes("chemistry") || lower.includes("biology") || lower.includes("science")) return "science";
+  if (lower.includes("ti\u1EBFng") || lower.includes("ng\u1EEF v\u0103n") || lower.includes("grammar") || lower.includes("language") || lower.includes("writing") || lower.includes("literature")) return "language";
+  return void 0;
+}
+function parseSyllabus(rawText) {
+  const lines = rawText.split(/\r?\n/);
+  let subjectTitle = "";
+  let subjectDesc = "";
+  const units = [];
+  const allTopics = [];
+  const globalKeywordsSet = /* @__PURE__ */ new Set();
+  let currentUnit = null;
+  let currentTopic = null;
+  let unitIndex = 0;
+  let topicIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    if (!line) continue;
+    if (line.startsWith("# ") && !subjectTitle) {
+      subjectTitle = line.replace(/^#\s+/, "").trim();
+      continue;
+    }
+    if (!currentUnit) {
+      if (line.toLowerCase().startsWith("m\xF4n h\u1ECDc:") || line.toLowerCase().startsWith("subject:")) {
+        const val = line.split(":")[1]?.trim() || "";
+        if (val && !subjectTitle) subjectTitle = val;
+      }
+      if (line.toLowerCase().startsWith("m\xF4 t\u1EA3:") || line.toLowerCase().startsWith("description:")) {
+        subjectDesc = line.split(":")[1]?.trim() || "";
+      }
+    }
+    const isUnitHeading = /^##\s+(?:chương|module|unit|phần|chủ đề)\s*(\d+|[ivx]+)?[:.-]?\s*(.*)/i.test(line) || /^##\s+([^#].*)/.test(line);
+    if (isUnitHeading) {
+      if (currentTopic) {
+        currentTopic.rawLineEnd = lineNum - 1;
+        currentTopic = null;
+      }
+      unitIndex += 1;
+      const titleMatch = line.replace(/^##\s+/, "").trim();
+      currentUnit = {
+        id: `U${String(unitIndex).padStart(2, "0")}`,
+        title: titleMatch,
+        order: unitIndex,
+        topics: []
+      };
+      units.push(currentUnit);
+      continue;
+    }
+    const isTopicItem = /^(?:-\s*\*\*(?:bài|topic|lesson|chủ đề)\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*?)\*\*)/i.exec(line) || /^###\s+(?:bài|topic|lesson)?\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*)/i.exec(line) || /^-\s+\*\*(.*?)\*\*/.exec(line) || /^(\d+)\.\s+(?:(?:\*\*)?(?:bài|topic|lesson)?\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*?)(?:\*\*)?)$/i.exec(line);
+    if (isTopicItem) {
+      if (currentTopic) {
+        currentTopic.rawLineEnd = lineNum - 1;
+      }
+      if (!currentUnit) {
+        unitIndex += 1;
+        currentUnit = {
+          id: `U${String(unitIndex).padStart(2, "0")}`,
+          title: subjectTitle || "General",
+          order: unitIndex,
+          topics: []
+        };
+        units.push(currentUnit);
+      }
+      topicIndex += 1;
+      const rawName = (isTopicItem[3] || isTopicItem[2] || isTopicItem[1] || `Topic ${topicIndex}`).trim();
+      currentTopic = {
+        id: `T${String(topicIndex).padStart(2, "0")}`,
+        title: rawName,
+        unitId: currentUnit.id,
+        unitTitle: currentUnit.title,
+        description: "",
+        learningObjectives: [],
+        keywords: [],
+        rawLineStart: lineNum,
+        rawLineEnd: lineNum
+      };
+      currentUnit.topics.push(currentTopic);
+      allTopics.push(currentTopic);
+      continue;
+    }
+    if (currentTopic) {
+      currentTopic.rawLineEnd = lineNum;
+      const stripped = line.replace(/^[-*•\s]+/, "").trim();
+      if (stripped.toLowerCase().startsWith("m\u1EE5c ti\xEAu:") || stripped.toLowerCase().startsWith("objectives:")) {
+        const content = stripped.replace(/^(?:mục tiêu|objectives):\s*/i, "").trim();
+        if (content) currentTopic.learningObjectives.push(content);
+        continue;
+      }
+      if (stripped.toLowerCase().startsWith("t\u1EEB kh\xF3a:") || stripped.toLowerCase().startsWith("keywords:")) {
+        const rawKw = stripped.replace(/^(?:từ khóa|keywords):\s*/i, "").trim();
+        const tokens2 = rawKw.split(/[,;]+/).map((k) => k.trim()).filter(Boolean);
+        for (const tok of tokens2) {
+          currentTopic.keywords.push(tok);
+          globalKeywordsSet.add(tok);
+        }
+        continue;
+      }
+      if (currentTopic.description) {
+        currentTopic.description += " " + stripped;
+      } else {
+        currentTopic.description = stripped;
+      }
+      for (const tok of extractTokens(stripped)) {
+        if (tok.length >= 4) globalKeywordsSet.add(tok);
+      }
+    }
+  }
+  if (currentTopic) {
+    currentTopic.rawLineEnd = lines.length;
+  }
+  if (!subjectTitle && units.length > 0) {
+    subjectTitle = units[0]?.title || "Untitled Subject";
+  }
+  return {
+    subject: {
+      title: subjectTitle || "Untitled Subject",
+      domain: extractDomain(rawText),
+      gradeBand: extractGradeBand(rawText),
+      description: subjectDesc
+    },
+    units,
+    allTopics,
+    extractedKeywords: [...globalKeywordsSet],
+    rawText
+  };
+}
+
+// src/graph/knowledgeGraphVerifier.ts
+function detectPrerequisiteCycles(concepts) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const path = [];
+  const prereqMap = /* @__PURE__ */ new Map();
+  for (const c of concepts) {
+    prereqMap.set(c.id, c.prerequisites || []);
+  }
+  function dfs(conceptId) {
+    if (inStack.has(conceptId)) {
+      const cycleStart = path.indexOf(conceptId);
+      if (cycleStart >= 0) {
+        cycles.push([...path.slice(cycleStart), conceptId]);
+      }
+      return;
+    }
+    if (visited.has(conceptId)) return;
+    visited.add(conceptId);
+    inStack.add(conceptId);
+    path.push(conceptId);
+    for (const prereq of prereqMap.get(conceptId) || []) {
+      dfs(prereq);
+    }
+    path.pop();
+    inStack.delete(conceptId);
+  }
+  for (const c of concepts) {
+    if (!visited.has(c.id)) {
+      dfs(c.id);
+    }
+  }
+  return cycles;
+}
+function breakPrerequisiteCycles(concepts, cycles) {
+  const removed = [];
+  const fixed = concepts.map((c) => ({ ...c, prerequisites: [...c.prerequisites || []] }));
+  for (const cycle of cycles) {
+    if (cycle.length >= 2) {
+      const breaker = cycle[cycle.length - 2];
+      const target = cycle[cycle.length - 1];
+      for (const concept of fixed) {
+        if (concept.id === breaker && target) {
+          concept.prerequisites = concept.prerequisites.filter((p) => p !== target);
+          removed.push({ from: breaker, to: target });
+        }
+      }
+    }
+  }
+  return { fixed, removed };
+}
+function auditSyllabusCoverage(concepts, syllabus) {
+  if (!syllabus || syllabus.allTopics.length === 0) {
+    return { coverageRatio: 1, totalTopics: 0, coveredTopics: 0, uncovered: [] };
+  }
+  const topics = syllabus.allTopics;
+  const coveredSet = /* @__PURE__ */ new Set();
+  for (const topic of topics) {
+    const topicKeywords = /* @__PURE__ */ new Set([
+      ...topic.title.toLowerCase().split(/\s+/),
+      ...(topic.keywords || []).map((k) => k.toLowerCase())
+    ]);
+    for (const concept of concepts) {
+      concept.name.toLowerCase();
+      (concept.description || "").toLowerCase();
+      (concept.keywords || []).map((k) => k.toLowerCase());
+      if (concept.id.toLowerCase() === topic.id.toLowerCase()) {
+        coveredSet.add(topic.id);
+        break;
+      }
+      const refs = concept.references || [];
+      const hasTopicRef = refs.some(
+        (r) => r.id === topic.id || r.title && r.title.toLowerCase() === topic.title.toLowerCase()
+      );
+      if (hasTopicRef) {
+        coveredSet.add(topic.id);
+        break;
+      }
+      const conceptKeywords = (concept.keywords || []).map((k) => k.toLowerCase());
+      const hasOverlap = conceptKeywords.some((k) => topicKeywords.has(k)) || concept.name.toLowerCase().includes(topic.title.toLowerCase()) || topic.title.toLowerCase().includes(concept.name.toLowerCase());
+      if (hasOverlap) {
+        coveredSet.add(topic.id);
+        break;
+      }
+    }
+  }
+  const totalTopics = topics.length;
+  const coveredTopics = coveredSet.size;
+  const coverageRatio = totalTopics > 0 ? coveredTopics / totalTopics : 1;
+  const uncovered = topics.filter((t) => !coveredSet.has(t.id)).map((t) => `${t.id}: ${t.title}`);
+  return { coverageRatio, totalTopics, coveredTopics, uncovered };
+}
+function verifyKnowledgeGraph(kg, syllabusOrOptions) {
+  const syllabus = syllabusOrOptions && "parsedSyllabus" in syllabusOrOptions ? syllabusOrOptions.parsedSyllabus : syllabusOrOptions;
+  const warnings = [];
+  let concepts = [...kg.concepts || []];
+  const conceptIds = new Set(concepts.map((c) => c.id));
+  for (const c of concepts) {
+    if ((c.prerequisites || []).includes(c.id)) {
+      c.prerequisites = (c.prerequisites || []).filter((p) => p !== c.id);
+      warnings.push(`Self-loop removed on concept ${c.id}`);
+    }
+  }
+  const danglingPrerequisites = [];
+  for (const c of concepts) {
+    const validPrereqs = [];
+    for (const p of c.prerequisites || []) {
+      if (!conceptIds.has(p)) {
+        danglingPrerequisites.push({ conceptId: c.id, missingPrereqId: p });
+        warnings.push(`Dangling prerequisite removed: ${c.id} -> ${p}`);
+      } else {
+        validPrereqs.push(p);
+      }
+    }
+    c.prerequisites = validPrereqs;
+  }
+  const initialCycles = detectPrerequisiteCycles(concepts);
+  let removedEdges = [];
+  if (initialCycles.length > 0) {
+    const broken = breakPrerequisiteCycles(concepts, initialCycles);
+    concepts = broken.fixed;
+    removedEdges = broken.removed;
+    for (const r of removedEdges) {
+      warnings.push(`Cycle broken: removed edge ${r.from} -> ${r.to}`);
+    }
+  }
+  const coverage = auditSyllabusCoverage(concepts, syllabus);
+  if (coverage.coverageRatio < 1) {
+    warnings.push(`Syllabus coverage ${(coverage.coverageRatio * 100).toFixed(1)}% (${coverage.coveredTopics}/${coverage.totalTopics} topics). Uncovered: ${coverage.uncovered.join(", ")}`);
+  }
+  for (const c of concepts) {
+    if (!c.ulo) warnings.push(`Concept ${c.id} missing ULO (WHAT + WHY)`);
+    if (!c.cio) warnings.push(`Concept ${c.id} missing CIO (HOW mechanism)`);
+    if (!c.sio || c.sio.length === 0) warnings.push(`Concept ${c.id} missing SIO implementation items`);
+  }
+  const valid = initialCycles.length === 0 && danglingPrerequisites.length === 0 && coverage.coverageRatio >= 0.8;
+  const verifiedGraph = {
+    ...kg,
+    concepts
+  };
+  const report = {
+    valid,
+    cycles: initialCycles,
+    removedEdges,
+    danglingPrerequisites,
+    coverageRatio: coverage.coverageRatio,
+    totalSyllabusTopics: coverage.totalTopics,
+    coveredSyllabusTopics: coverage.coveredTopics,
+    uncoveredTopics: coverage.uncovered,
+    warnings
+  };
+  return { verifiedGraph, report };
+}
+
 // src/graph/loExemplars.ts
 var ULO_EXEMPLARS = [
   // Calibrated against production learning_objectives (UNIVERSAL rows, neutral)
@@ -1565,58 +1904,6 @@ async function standardizeConcepts(opts) {
 }
 
 // src/graph/knowledgeGraphPipeline.ts
-function detectCycles(concepts) {
-  const cycles = [];
-  const visited = /* @__PURE__ */ new Set();
-  const inStack = /* @__PURE__ */ new Set();
-  const path = [];
-  function dfs(conceptId, prereqMap2) {
-    if (inStack.has(conceptId)) {
-      const cycleStart = path.indexOf(conceptId);
-      if (cycleStart >= 0) {
-        cycles.push([...path.slice(cycleStart), conceptId]);
-      }
-      return;
-    }
-    if (visited.has(conceptId)) return;
-    visited.add(conceptId);
-    inStack.add(conceptId);
-    path.push(conceptId);
-    const prereqs = prereqMap2.get(conceptId) || [];
-    for (const prereq of prereqs) {
-      dfs(prereq, prereqMap2);
-    }
-    path.pop();
-    inStack.delete(conceptId);
-  }
-  const prereqMap = /* @__PURE__ */ new Map();
-  for (const concept of concepts) {
-    prereqMap.set(concept.id, concept.prerequisites || []);
-  }
-  for (const concept of concepts) {
-    if (!visited.has(concept.id)) {
-      dfs(concept.id, prereqMap);
-    }
-  }
-  return cycles;
-}
-function breakCycles(concepts, cycles) {
-  const removed = [];
-  const fixed = concepts.map((c) => ({ ...c, prerequisites: [...c.prerequisites || []] }));
-  for (const cycle of cycles) {
-    if (cycle.length >= 2) {
-      const breaker = cycle[cycle.length - 2];
-      const target = cycle[cycle.length - 1];
-      for (const concept of fixed) {
-        if (concept.id === breaker) {
-          concept.prerequisites = concept.prerequisites.filter((p) => p !== target);
-          removed.push({ from: breaker, to: target });
-        }
-      }
-    }
-  }
-  return { fixed, removed };
-}
 function topologicalSort(concepts) {
   const inDegree = /* @__PURE__ */ new Map();
   const adjacency = /* @__PURE__ */ new Map();
@@ -1657,6 +1944,11 @@ async function generateKnowledgeGraph(options) {
     onProgress?.(step, msg);
   };
   log("STEP_1", "Decomposing subject into concepts...");
+  let parsedSyllabus = options.parsedSyllabus;
+  if (!parsedSyllabus && syllabusText) {
+    parsedSyllabus = parseSyllabus(syllabusText);
+    log("STEP_1", `Parsed syllabus: ${parsedSyllabus.units.length} units, ${parsedSyllabus.allTopics.length} topics`);
+  }
   const client = createLlmClient(llmConfig);
   const maxSyllabusChars = parseInt(process.env.KG_MAX_SYLLABUS_CHARS || "16000", 10);
   let truncatedSyllabus = "";
@@ -1668,10 +1960,13 @@ async function generateKnowledgeGraph(options) {
       truncatedSyllabus = syllabusText;
     }
   }
+  const structuredTopicsGuide = parsedSyllabus && parsedSyllabus.allTopics.length > 0 ? `
+STRUCTURED SYLLABUS TOPICS (Every topic MUST map to at least one concept to ensure 100% syllabus coverage):
+` + parsedSyllabus.allTopics.map((t) => `- [${t.unitTitle}] ${t.id}: ${t.title} (Keywords: ${t.keywords.join(", ")})`).join("\n") + "\n" : "";
   const systemPrompt = "You are an expert curriculum designer. Decompose the given subject into a structured knowledge graph with concepts, prerequisites, and problem types.\n\nCRITICAL RULES:\n1. Each concept MUST have the three depth layers, authored against this CONTRACT:\n   - ulo (WHAT + WHY): bound to the CONCEPT's intrinsic NATURE. It explains what the\n     concept is and why it exists \u2014 the problem it solves in principle. It must be\n     TECHNOLOGY-AGNOSTIC: never name a concrete library, API, function, file format,\n     tool or language feature. Typical assessment level: Remember / Understand.\n   - cio (HOW): the MECHANISM \u2014 how the concept works and solves that problem, step\n     by step. Still bound to the concept's nature: more concrete than the ULO, but\n     NOT tied to one specific technology (no concrete API names). CIO capability is\n     assessed INDIRECTLY, through completing contextual work, not in isolation.\n   - sio (IMPLEMENTATION): an array of 2-4 items. EVERY item MUST reference concrete\n     KEYWORDS/technologies (a real API, function, module, file, or named pattern) and\n     describe a completable, context-specific implementation task. Application,\n     Analysis and Creation skills are assessed INDIRECTLY through completing these\n     items. There is NO fixed Bloom ceiling for a layer \u2014 but concreteness MUST\n     strictly increase: SIO more technology-bound than CIO, CIO more concrete than ULO.\n   - prerequisites: concept IDs that must be learned first (MUST NOT create cycles)\n   - problem_types: 2-4 problem types with bloom_level and difficulty. Remember and\n     Understand problem types test the ULO/CIO directly; Apply-and-above types are\n     proxies for SIO completion in context.\n   - techniques: methods, formulas, tools\n2. Prerequisite chains MUST be acyclic (no concept can depend on itself or create a loop)\n3. Concepts should be ordered by prerequisite dependency (topological sort)\n4. Problem types should range from Remember to Apply (not all at same level)\n5. Group concepts into categories (chapters/sections)\n6. ALL text in ENGLISH (even if input is Vietnamese)\n7. NEVER invent concepts not present in the syllabus\n8. Return JSON matching the KnowledgeGraphSchema";
   const userPrompt = `Subject: ${subject}
 ${description ? `Description: ${description}` : ""}
-${truncatedSyllabus ? `Syllabus:
+${structuredTopicsGuide}${truncatedSyllabus ? `Syllabus:
 ${truncatedSyllabus}` : ""}
 ${gradeBand ? `Grade band: ${gradeBand[0]}-${gradeBand[1]}` : ""}
 ${domain ? `Domain: ${domain}` : ""}
@@ -1816,13 +2111,13 @@ Return JSON:
     log("STEP_2_5", "Standardized: " + std.decisions.filter((d) => d.decision === "standardized").length + ", proposed new: " + std.decisions.filter((d) => d.decision === "proposed_new").length);
   }
   log("STEP_3", "Checking for prerequisite cycles...");
-  const cycles = detectCycles(concepts);
+  const cycles = detectPrerequisiteCycles(concepts);
   if (cycles.length > 0) {
     log("STEP_3", `Found ${cycles.length} cycle(s) in prerequisite chain \u2014 breaking cycles`);
     for (const cycle of cycles) {
       warnings.push(`Cycle detected: ${cycle.join(" \u2192 ")} \u2014 breaking at weakest edge`);
     }
-    const { fixed, removed } = breakCycles(concepts, cycles);
+    const { fixed, removed } = breakPrerequisiteCycles(concepts, cycles);
     for (let i = 0; i < concepts.length; i++) {
       const fixedConcept = fixed.find((f) => f.id === concepts[i].id);
       if (fixedConcept) {
@@ -1873,16 +2168,21 @@ Return JSON:
     }
   }
   log("STEP_2", `Validated ${concepts.length} concepts, ${categories.length} categories, ${learningPath.length} learning path steps`);
+  const rawGraph = {
+    schema_version: 1,
+    type: "knowledge_graph",
+    subject: result.subject,
+    concepts,
+    categories,
+    learning_path: learningPath
+  };
+  log("STEP_6", "Running Knowledge Graph verification & reverse coverage audit...");
+  const { verifiedGraph, report } = verifyKnowledgeGraph(rawGraph, parsedSyllabus);
+  warnings.push(...report.warnings);
   return {
-    knowledgeGraph: {
-      schema_version: 1,
-      type: "knowledge_graph",
-      subject: result.subject,
-      concepts,
-      categories,
-      learning_path: learningPath
-    },
-    warnings
+    knowledgeGraph: verifiedGraph,
+    warnings,
+    verificationReport: report
   };
 }
 
@@ -2148,9 +2448,12 @@ exports.SIO_CODE_RE = SIO_CODE_RE;
 exports.ULO_CODE_RE = ULO_CODE_RE;
 exports.assignConceptCodes = assignConceptCodes;
 exports.auditDepthLayers = auditDepthLayers;
+exports.auditSyllabusCoverage = auditSyllabusCoverage;
+exports.breakPrerequisiteCycles = breakPrerequisiteCycles;
 exports.cioActionSlug = cioActionSlug;
 exports.cioCode = cioCode;
 exports.conceptCodeFromName = conceptCodeFromName;
+exports.detectPrerequisiteCycles = detectPrerequisiteCycles;
 exports.escalateAndMapConcepts = escalateAndMapConcepts;
 exports.extractFeatureSteps = extractFeatureSteps;
 exports.extractFeatureStepsBatched = extractFeatureStepsBatched;
@@ -2162,6 +2465,7 @@ exports.sioCode = sioCode;
 exports.standardStatement = standardStatement;
 exports.techTagFor = techTagFor;
 exports.uloCode = uloCode;
+exports.verifyKnowledgeGraph = verifyKnowledgeGraph;
 exports.verifyProjectGraph = verifyProjectGraph;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map