@thanh01.pmt/domain-kit 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -6,7 +6,492 @@ var os = require('os');
 var path = require('path');
 var child_process = require('child_process');
 
-// src/schemas/projectGraphSchema.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function validateCurriculumFeed(feed) {
+  const parsed = exports.CurriculumFeedSchema.parse(feed);
+  const ids = new Set(parsed.learning_nodes.map((n) => n.id));
+  if (ids.size !== parsed.learning_nodes.length) {
+    throw new Error("curriculum feed contains duplicate node ids");
+  }
+  for (const e of parsed.dependency_edges) {
+    if (!ids.has(e.from) || !ids.has(e.to)) {
+      throw new Error("curriculum feed edge " + e.from + " -> " + e.to + " references unknown node");
+    }
+    if (e.from === e.to) throw new Error("curriculum feed self-loop edge on " + e.from);
+  }
+  for (const g of parsed.suggested_groupings) {
+    for (const id of g.node_ids) {
+      if (!ids.has(id)) throw new Error("grouping " + g.id + " references unknown node " + id);
+    }
+  }
+  for (const ph of parsed.phases) {
+    for (const id of ph.node_ids) {
+      if (!ids.has(id)) throw new Error("phase " + ph.id + " references unknown node " + id);
+    }
+  }
+  const phaseIds = parsed.phases.map((p) => p.id);
+  if (new Set(phaseIds).size !== phaseIds.length) throw new Error("curriculum feed contains duplicate phase ids");
+  return parsed;
+}
+exports.FeedKeywordsSchema = void 0; exports.FeedScaffoldCandidateSchema = void 0; exports.FeedNodeSchema = void 0; exports.FeedEdgeSchema = void 0; exports.FeedGroupingSchema = void 0; exports.FeedPhaseSchema = void 0; exports.CurriculumFeedSchema = void 0;
+var init_curriculumFeedSchema = __esm({
+  "src/schemas/curriculumFeedSchema.ts"() {
+    exports.FeedKeywordsSchema = zod.z.object({
+      all: zod.z.array(zod.z.string()).default([]),
+      new: zod.z.array(zod.z.string()).default([]),
+      prerequisite: zod.z.array(zod.z.string()).default([])
+    });
+    exports.FeedScaffoldCandidateSchema = zod.z.object({
+      item: zod.z.string(),
+      reason: zod.z.string().default(""),
+      minutes_saved: zod.z.number().int().nonnegative().default(0),
+      suggest: zod.z.enum(["provide_full", "provide_partial", "provide_reference"]).default("provide_full")
+    });
+    exports.FeedNodeSchema = zod.z.object({
+      id: zod.z.string().min(1),
+      kind: zod.z.enum(["skill", "concept", "product_step"]),
+      name: zod.z.string().min(1),
+      concept_codes: zod.z.array(zod.z.string()).default([]),
+      keywords: exports.FeedKeywordsSchema,
+      estimated_minutes: zod.z.number().int().nonnegative(),
+      bloom_hint: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]).nullable().default(null),
+      depth_hint: zod.z.enum(["ulo", "cio", "sio"]).nullable().default(null),
+      completion_level: zod.z.enum(["mvp", "standard", "stretch"]).default("standard"),
+      scaffolding: zod.z.object({
+        scaffold_candidates: zod.z.array(exports.FeedScaffoldCandidateSchema).default([]),
+        core_value_minutes: zod.z.number().int().nonnegative().default(0)
+      }).default({ scaffold_candidates: [], core_value_minutes: 0 }),
+      references: zod.z.array(zod.z.object({ file: zod.z.string().min(1), evidence: zod.z.string().default("") })).default([]),
+      feature_id: zod.z.string().nullable().default(null),
+      concept_ref: zod.z.string().nullable().default(null),
+      // Progressive-completion bookkeeping (feed v2, additive):
+      // phase_id = development phase that introduces/uses this node;
+      // introduce_aspect = how the phase teaches a concept node (first intro vs advanced revisit).
+      phase_id: zod.z.string().default(""),
+      introduce_aspect: zod.z.enum(["new", "advanced"]).nullable().default(null)
+    });
+    exports.FeedEdgeSchema = zod.z.object({
+      from: zod.z.string().min(1),
+      to: zod.z.string().min(1),
+      kind: zod.z.enum(["knowledge", "task"]),
+      reason: zod.z.string().default("")
+    });
+    exports.FeedGroupingSchema = zod.z.object({
+      id: zod.z.string().min(1),
+      name: zod.z.string().min(1),
+      node_ids: zod.z.array(zod.z.string()).min(1),
+      rationale: zod.z.string().default("")
+    });
+    exports.FeedPhaseSchema = zod.z.object({
+      id: zod.z.string().min(1),
+      order: zod.z.number().int().positive(),
+      name: zod.z.string().min(1),
+      product_completion: zod.z.string().min(1),
+      node_ids: zod.z.array(zod.z.string()).min(1)
+    });
+    exports.CurriculumFeedSchema = zod.z.object({
+      schema_version: zod.z.literal(2),
+      source: zod.z.object({
+        graph_type: zod.z.enum(["project_graph", "knowledge_graph", "hybrid_graph"]),
+        warnings: zod.z.array(zod.z.string()).default([]),
+        hallucination_count: zod.z.number().int().nonnegative().default(0)
+      }),
+      learning_nodes: zod.z.array(exports.FeedNodeSchema).min(1, "curriculum feed must contain at least one learning node"),
+      dependency_edges: zod.z.array(exports.FeedEdgeSchema).default([]),
+      suggested_groupings: zod.z.array(exports.FeedGroupingSchema).default([]),
+      // Progressive completion phases (cross-feature). When non-empty, these — not
+      // suggested_groupings — define the teaching sequence and unit structure.
+      phases: zod.z.array(exports.FeedPhaseSchema).default([])
+    });
+  }
+});
+
+// src/feed/curriculumFeedEmitter.ts
+var curriculumFeedEmitter_exports = {};
+__export(curriculumFeedEmitter_exports, {
+  emitCurriculumFeed: () => emitCurriculumFeed
+});
+function stepMinutes(step) {
+  const effort = step.effort ?? {};
+  return Math.max(0, Math.round(num(effort.estimated_minutes, num(step.estimated_minutes, 45))));
+}
+function newKeywordsInOrder(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    const all = n.keywords.all;
+    n.keywords.new = [];
+    n.keywords.prerequisite = [];
+    for (const k of all) {
+      if (seen.has(k)) n.keywords.prerequisite.push(k);
+      else n.keywords.new.push(k);
+      seen.add(k);
+    }
+  }
+}
+function feedNodeFromStep(step, featureId) {
+  const id = str(step.id);
+  return {
+    id,
+    kind: "product_step",
+    name: str(step.name, id),
+    concept_codes: strs(step.concept_codes),
+    keywords: { all: strs(step.keywords), new: [], prerequisite: [] },
+    estimated_minutes: stepMinutes(step),
+    bloom_hint: "Apply",
+    depth_hint: null,
+    completion_level: "standard",
+    scaffolding: { scaffold_candidates: [], core_value_minutes: stepMinutes(step) },
+    references: arr(step.files).map((f) => ({ file: str(f), evidence: "step file" })).filter((f) => f.file),
+    feature_id: featureId,
+    concept_ref: null,
+    phase_id: "",
+    introduce_aspect: null
+  };
+}
+function deriveConceptDepthHint(concept) {
+  const explicit = str(concept.depth_hint);
+  if (explicit === "ulo" || explicit === "cio" || explicit === "sio") return explicit;
+  const sio = arr(concept.sio);
+  const prereqs = strs(concept.prerequisites);
+  const pts = arr(concept.problem_types);
+  const hasHighBloom = pts.some((p) => {
+    const b = str(p.bloom_level);
+    return b === "Apply" || b === "Analyze" || b === "Evaluate" || b === "Create";
+  });
+  if (sio.length >= 2 || hasHighBloom) return "sio";
+  if (str(concept.cio) || prereqs.length >= 1) return "cio";
+  return "ulo";
+}
+function feedNodeFromConcept(concept) {
+  const id = str(concept.id);
+  const pts = arr(concept.problem_types).map((p) => str(p.bloom_level, "Understand")).filter((b) => b in BLOOM_RANK).sort((a, b) => BLOOM_RANK[a] - BLOOM_RANK[b]);
+  const topBloom = pts[pts.length - 1] ?? "Understand";
+  const rawRefs = arr(concept.references);
+  const references = rawRefs.length > 0 ? rawRefs.map((r) => ({ file: str(r.file, "syllabus.md"), evidence: str(r.evidence, str(concept.name)) })).filter((r) => r.file) : [{ file: "syllabus.md", evidence: str(concept.category ? `Topic under category ${str(concept.category)}` : str(concept.name), id) }];
+  const problemScaffolds = arr(concept.problem_types).map((pt) => ({
+    item: str(pt.name, "Problem type"),
+    reason: str(pt.description, "Formative practice check"),
+    minutes_saved: num(pt.estimated_minutes, 10),
+    suggest: "provide_partial"
+  }));
+  return {
+    id,
+    kind: "concept",
+    name: str(concept.name, id),
+    concept_codes: [str(concept.code) || id].filter(Boolean),
+    keywords: { all: strs(concept.keywords), new: [], prerequisite: [] },
+    estimated_minutes: Math.max(0, Math.round(num(concept.estimated_minutes, 30))),
+    bloom_hint: topBloom,
+    depth_hint: deriveConceptDepthHint(concept),
+    completion_level: "standard",
+    scaffolding: {
+      scaffold_candidates: problemScaffolds,
+      core_value_minutes: Math.max(0, Math.round(num(concept.estimated_minutes, 30)))
+    },
+    references,
+    feature_id: null,
+    concept_ref: id,
+    phase_id: "",
+    introduce_aspect: null
+  };
+}
+function addFeatureGroup(f, fid, nodes, edges, groupings) {
+  const steps = arr(f.steps);
+  const stepIds = [];
+  let prev = "";
+  for (let i = 0; i < steps.length; i++) {
+    const stepNode = feedNodeFromStep(steps[i], fid);
+    if (!stepNode.id) continue;
+    stepIds.push(stepNode.id);
+    nodes.push(stepNode);
+    if (prev) edges.push({ from: prev, to: stepNode.id, kind: "task", reason: "feature build order" });
+    prev = stepNode.id;
+  }
+  for (const dep of strs(f.depends_on)) {
+    const depFirst = nodes.find((n) => n.feature_id === dep);
+    if (depFirst && stepIds[0]) edges.push({ from: depFirst.id, to: stepIds[0], kind: "task", reason: "feature depends_on " + dep });
+  }
+  if (stepIds.length > 0) groupings.push({ id: "G-" + fid, name: str(f.name, fid), node_ids: stepIds, rationale: str(f.description, "") });
+  return stepIds;
+}
+function emitFromHybrid(hybrid, opts) {
+  const nodes = [];
+  const edges = [];
+  const groupings = [];
+  const pg = hybrid.project_graph ?? {};
+  const kg = hybrid.knowledge_graph ?? {};
+  const rawPhases = arr(hybrid.phases).filter((p) => str(p.id));
+  const features = arr(pg.features);
+  const conceptRecs = arr(kg.concepts);
+  const conceptById = new Map(conceptRecs.map((c) => [str(c.id), c]));
+  if (rawPhases.length === 0) {
+    for (const c of conceptRecs) {
+      const node = feedNodeFromConcept(c);
+      nodes.push(node);
+      for (const p of strs(c.prerequisites)) edges.push({ from: p, to: node.id, kind: "knowledge", reason: "concept prerequisite" });
+    }
+    features.forEach((f, fi) => addFeatureGroup(f, str(f.id, "F" + pad22(fi + 1)), nodes, edges, groupings));
+    linkHybridKnowledgeEdges(hybrid, nodes, edges);
+    newKeywordsInOrder(nodes);
+    return validateCurriculumFeed({
+      schema_version: 2,
+      source: { graph_type: "hybrid_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
+      learning_nodes: nodes,
+      dependency_edges: edges,
+      suggested_groupings: groupings,
+      phases: []
+    });
+  }
+  const featureOrder = /* @__PURE__ */ new Map();
+  features.forEach((f, fi) => featureOrder.set(str(f.id, "F" + pad22(fi + 1)), fi));
+  const stepIdsByFeature = /* @__PURE__ */ new Map();
+  for (const f of features) {
+    const fid = str(f.id);
+    stepIdsByFeature.set(fid, arr(f.steps).map((s) => str(s.id)).filter(Boolean));
+  }
+  const emitCtx = [];
+  const emittedConcepts = /* @__PURE__ */ new Set();
+  const linkList = arr(hybrid.links);
+  for (const rp of rawPhases) {
+    const pid = str(rp.id);
+    const order = num(rp.order, emitCtx.length + 1);
+    const conceptOrder = [];
+    const intros = arr(rp.introduces);
+    const news = intros.filter((i) => str(i.aspect, "new") === "new");
+    const advanced = intros.filter((i) => str(i.aspect) === "advanced");
+    for (const intro of [...news, ...advanced]) {
+      const cid = str(intro.concept_id);
+      const c = conceptById.get(cid);
+      if (!c) {
+        throw new Error("Phase " + pid + " introduces unknown concept " + cid + " - fail-closed");
+      }
+      if (str(intro.aspect, "new") === "advanced" && !emittedConcepts.has(cid)) {
+        throw new Error("Phase " + pid + " advanced-revisits concept " + cid + " that was never emitted - fail-closed");
+      }
+      if (!emittedConcepts.has(cid)) {
+        const node = feedNodeFromConcept(c);
+        node.phase_id = pid;
+        node.introduce_aspect = "new";
+        nodes.push(node);
+        for (const p of strs(c.prerequisites)) {
+          if (!emittedConcepts.has(p)) {
+            throw new Error("Concept " + cid + " (phase " + pid + ") has prerequisite " + p + " that is not introduced in an earlier phase - fail-closed");
+          }
+          edges.push({ from: p, to: cid, kind: "knowledge", reason: "concept prerequisite" });
+        }
+        emittedConcepts.add(cid);
+        conceptOrder.push(cid);
+      } else {
+        const revisitId = cid + "__ADV" + pad22(order);
+        const node = feedNodeFromConcept(c);
+        node.id = revisitId;
+        node.name = str(c.name, cid) + " (advanced)";
+        node.phase_id = pid;
+        node.introduce_aspect = "advanced";
+        node.estimated_minutes = Math.max(15, Math.round(node.estimated_minutes * 0.5));
+        node.concept_codes = [str(c.code) || cid];
+        edges.push({ from: cid, to: revisitId, kind: "knowledge", reason: "advanced revisit of " + cid + " at phase " + pid });
+        nodes.push(node);
+        conceptOrder.push(revisitId);
+      }
+    }
+    const featureIds = strs(rp.feature_ids).filter((fid) => featureOrder.has(fid)).sort((a, b) => featureOrder.get(a) - featureOrder.get(b));
+    emitCtx.push({ id: pid, order, name: str(rp.name, pid), productCompletion: str(rp.product_completion), conceptOrder, featureIds });
+  }
+  for (const l of linkList) {
+    const cid = str(l.concept_id);
+    if (cid && conceptById.has(cid) && !emittedConcepts.has(cid)) {
+      throw new Error("Concept " + cid + " is consumed by links but never introduced in any phase - fail-closed");
+    }
+  }
+  const seenFeatures = new Set(emitCtx.flatMap((e) => e.featureIds));
+  const missingFeatures = features.map((f) => str(f.id)).filter((fid) => fid && !seenFeatures.has(fid));
+  if (missingFeatures.length > 0) {
+    throw new Error("Features not covered by any phase: " + missingFeatures.join(", ") + " - fail-closed");
+  }
+  const phaseNodeIds = [];
+  for (const ctx of emitCtx) {
+    const ids = [...ctx.conceptOrder];
+    for (const fid of ctx.featureIds) {
+      const f = features.find((x) => str(x.id) === fid);
+      const stepIds = addFeatureGroup(f, fid, nodes, edges, groupings);
+      for (const sid of stepIds) {
+        const node = nodes.find((n) => n.id === sid);
+        node.phase_id = ctx.id;
+      }
+      ids.push(...stepIds);
+    }
+    phaseNodeIds.push(ids);
+  }
+  const edgeSeen = new Set(edges.map((e) => e.from + ">" + e.to));
+  const pushEdge = (from, to, reason) => {
+    const key = from + ">" + to;
+    if (edgeSeen.has(key)) return;
+    edgeSeen.add(key);
+    edges.push({ from, to, kind: "knowledge", reason });
+  };
+  for (const l of linkList) {
+    const cid = str(l.concept_id);
+    const fid = str(l.feature_id);
+    if (!conceptById.has(cid)) continue;
+    const firstStep = (stepIdsByFeature.get(fid) || [])[0];
+    if (!firstStep) continue;
+    const depth = str(l.depth, "cio");
+    pushEdge(cid, firstStep, str(l.relationship, "hybrid link") + " [" + depth + "]");
+    for (const n of nodes) {
+      if (n.kind === "concept" && n.concept_ref === cid && n.introduce_aspect === "advanced" && n.phase_id === str(l.phase_id)) {
+        pushEdge(n.id, firstStep, "advanced application [" + depth + "]");
+      }
+    }
+  }
+  newKeywordsInOrder(nodes);
+  const feedOrder = new Map(nodes.map((n, i) => [n.id, i]));
+  const introducer = /* @__PURE__ */ new Map();
+  for (const n of nodes) for (const k of n.keywords?.new ?? []) {
+    const key = k.toLowerCase();
+    if (!introducer.has(key)) introducer.set(key, n.id);
+  }
+  for (const n of nodes) {
+    for (const k of n.keywords?.prerequisite ?? []) {
+      const src = introducer.get(k.toLowerCase());
+      if (!src || src === n.id) continue;
+      if (feedOrder.get(src) < feedOrder.get(n.id)) pushEdge(src, n.id, "keyword prerequisite [" + k + "]");
+    }
+  }
+  const phases = emitCtx.map((ctx, i) => ({
+    id: ctx.id,
+    order: ctx.order,
+    name: ctx.name,
+    product_completion: ctx.productCompletion || "Phase " + (i + 1) + " deliverable",
+    node_ids: phaseNodeIds[i]
+  }));
+  return validateCurriculumFeed({
+    schema_version: 2,
+    source: { graph_type: "hybrid_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
+    learning_nodes: nodes,
+    dependency_edges: edges,
+    suggested_groupings: groupings,
+    phases
+  });
+}
+function linkHybridKnowledgeEdges(hybrid, nodes, edges, setStepHints) {
+  const conceptIds = new Set(nodes.filter((n) => n.kind === "concept").map((n) => n.concept_ref || n.id));
+  for (const l of arr(hybrid.links)) {
+    const conceptId = str(l.concept_id);
+    const featureId = str(l.feature_id);
+    if (!conceptIds.has(conceptId)) continue;
+    const depth = str(l.depth, "cio");
+    const firstStep = nodes.find((n) => n.feature_id === featureId);
+    if (firstStep) {
+      edges.push({ from: conceptId, to: firstStep.id, kind: "knowledge", reason: str(l.relationship, "hybrid link") + " [" + depth + "]" });
+      if (!firstStep.depth_hint) {
+        firstStep.depth_hint = ["ulo", "cio", "sio"].includes(depth) ? depth : "cio";
+      }
+    }
+  }
+}
+function emitFromKnowledge(kg, opts) {
+  const nodes = [];
+  const edges = [];
+  const groupings = [];
+  const conceptIds = new Set(arr(kg.concepts).map((c) => str(c.id)));
+  for (const c of arr(kg.concepts)) {
+    const node = feedNodeFromConcept(c);
+    nodes.push(node);
+    for (const p of strs(c.prerequisites)) {
+      if (p !== node.id && conceptIds.has(p)) {
+        edges.push({
+          from: p,
+          to: node.id,
+          kind: "knowledge",
+          reason: `concept prerequisite: ${p} must be understood before ${node.id}`
+        });
+      }
+    }
+  }
+  if (arr(kg.learning_path).length > 0) {
+    const orderMap = /* @__PURE__ */ new Map();
+    arr(kg.learning_path).forEach((s, idx) => {
+      const cid = str(s.concept_id);
+      if (cid) orderMap.set(cid, num(s.order, idx + 1));
+    });
+    nodes.sort((a, b) => (orderMap.get(a.id) ?? 999) - (orderMap.get(b.id) ?? 999));
+  }
+  let ci = 0;
+  for (const cat of arr(kg.categories)) {
+    ci += 1;
+    const ids = strs(cat.concept_ids).filter((id) => nodes.some((n) => n.id === id));
+    if (ids.length > 0) {
+      groupings.push({
+        id: str(cat.id, "cat" + ci),
+        name: str(cat.name, "Category " + ci),
+        node_ids: ids,
+        rationale: str(cat.description, "")
+      });
+    }
+  }
+  newKeywordsInOrder(nodes);
+  return validateCurriculumFeed({
+    schema_version: 2,
+    source: { graph_type: "knowledge_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
+    learning_nodes: nodes,
+    dependency_edges: edges,
+    suggested_groupings: groupings,
+    phases: []
+  });
+}
+function emitFromProject(pg, opts) {
+  const nodes = [];
+  const edges = [];
+  const groupings = [];
+  arr(pg.features).forEach((f, fi) => addFeatureGroup(f, str(f.id, "F" + pad22(fi + 1)), nodes, edges, groupings));
+  if (nodes.length === 0 && arr(pg.features).length > 0) {
+    const hasTasks = arr(pg.implementation ?? {}).length > 0 || arr(pg.implementation?.tasks).length > 0;
+    throw new Error(
+      "Project graph has " + arr(pg.features).length + " features but NO features[].steps - the curriculum feed cannot emit planning nodes." + (hasTasks ? " This looks like a legacy knowledge-tree graph (implementation.tasks). Regenerate it with the domain-kit v3 pipeline (runProjectGraphPipeline / hybridGraphPipeline), then re-run." : " Every feature must carry at least one step with id/name/keywords/effort for curriculum planning.")
+    );
+  }
+  newKeywordsInOrder(nodes);
+  return validateCurriculumFeed({
+    schema_version: 2,
+    source: { graph_type: "project_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
+    learning_nodes: nodes,
+    dependency_edges: edges,
+    suggested_groupings: groupings,
+    phases: []
+  });
+}
+function emitCurriculumFeed(graph, opts = {}) {
+  const g = graph;
+  if (arr(g.learning_nodes).length > 0) {
+    return validateCurriculumFeed(g);
+  }
+  if (g.project_graph || g.knowledge_graph || arr(g.links).length > 0 || arr(g.phases).length > 0) {
+    return emitFromHybrid(g, opts);
+  }
+  if (arr(g.concepts).length > 0 || str(g.type) === "knowledge_graph") return emitFromKnowledge(g, opts);
+  return emitFromProject(g, opts);
+}
+var BLOOM_RANK, pad22, arr, str, num, strs;
+var init_curriculumFeedEmitter = __esm({
+  "src/feed/curriculumFeedEmitter.ts"() {
+    init_curriculumFeedSchema();
+    BLOOM_RANK = { Remember: 0, Understand: 1, Apply: 2, Analyze: 3, Evaluate: 4, Create: 5 };
+    pad22 = (n) => String(n).padStart(2, "0");
+    arr = (v) => Array.isArray(v) ? v : [];
+    str = (v, d = "") => typeof v === "string" ? v : d;
+    num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+    strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  }
+});
 var StepEffortSchema = zod.z.object({
   estimated_minutes: zod.z.number().optional(),
   complexity: zod.z.enum(["low", "medium", "high"]).optional(),
@@ -378,6 +863,51 @@ var ThreeDesignTechStackExtensionSchema = zod.z.object({
   canvas_size: zod.z.string().optional(),
   export_formats: zod.z.array(zod.z.string()).optional().default([]).describe("STL, OBJ, STEP")
 });
+var MathTheoremSchema = zod.z.object({
+  name: zod.z.string(),
+  statement: zod.z.string(),
+  proof_outline: zod.z.string().optional(),
+  converse_statement: zod.z.string().optional()
+});
+var MathConceptExtensionSchema = zod.z.object({
+  formulas: zod.z.array(zod.z.string()).optional().default([]).describe("Mathematical formulas, e.g. a^2 + b^2 = c^2"),
+  theorems: zod.z.array(MathTheoremSchema).optional().default([]),
+  constructions: zod.z.array(zod.z.string()).optional().default([]).describe("Compass and ruler constructions, auxiliary lines"),
+  visual_aids: zod.z.array(zod.z.string()).optional().default([]).describe("Geometric figures, function graphs"),
+  common_mistakes: zod.z.array(zod.z.string()).optional().default([]).describe("False intuitions or algebraic traps")
+});
+var ExperimentProcedureSchema = zod.z.object({
+  name: zod.z.string(),
+  apparatus: zod.z.array(zod.z.string()).optional().default([]),
+  steps: zod.z.array(zod.z.string()).optional().default([]),
+  safety_warnings: zod.z.array(zod.z.string()).optional().default([]),
+  expected_observation: zod.z.string().optional()
+});
+var ScienceConceptExtensionSchema = zod.z.object({
+  experiments: zod.z.array(ExperimentProcedureSchema).optional().default([]),
+  instruments: zod.z.array(zod.z.string()).optional().default([]).describe("Lab equipment: microscope, beaker, sensor"),
+  variables: zod.z.object({
+    independent: zod.z.string().optional(),
+    dependent: zod.z.string().optional(),
+    controlled: zod.z.array(zod.z.string()).optional().default([])
+  }).optional(),
+  hypotheses: zod.z.array(zod.z.string()).optional().default([]),
+  laws_and_theories: zod.z.array(zod.z.string()).optional().default([])
+});
+var GrammarRuleSchema = zod.z.object({
+  rule_name: zod.z.string(),
+  pattern: zod.z.string(),
+  example_correct: zod.z.string(),
+  example_incorrect: zod.z.string().optional(),
+  exceptions: zod.z.array(zod.z.string()).optional().default([])
+});
+var LanguageConceptExtensionSchema = zod.z.object({
+  reading_genres: zod.z.array(zod.z.string()).optional().default([]).describe("argumentative, narrative, expository"),
+  grammar_rules: zod.z.array(GrammarRuleSchema).optional().default([]),
+  writing_tasks: zod.z.array(zod.z.string()).optional().default([]),
+  lexicon_keywords: zod.z.array(zod.z.string()).optional().default([]),
+  rhetorical_devices: zod.z.array(zod.z.string()).optional().default([])
+});
 var ProjectConceptLinkSchema = zod.z.object({
   feature_id: zod.z.string().describe("Feature ID from project_graph"),
   concept_id: zod.z.string().describe("Concept ID from knowledge_graph"),
@@ -516,99 +1046,9 @@ var DomainProfileSchema = zod.z.object({
   repoDir: zod.z.string().optional().default(""),
   syllabusText: zod.z.string().optional().default("")
 });
-var FeedKeywordsSchema = zod.z.object({
-  all: zod.z.array(zod.z.string()).default([]),
-  new: zod.z.array(zod.z.string()).default([]),
-  prerequisite: zod.z.array(zod.z.string()).default([])
-});
-var FeedScaffoldCandidateSchema = zod.z.object({
-  item: zod.z.string(),
-  reason: zod.z.string().default(""),
-  minutes_saved: zod.z.number().int().nonnegative().default(0),
-  suggest: zod.z.enum(["provide_full", "provide_partial", "provide_reference"]).default("provide_full")
-});
-var FeedNodeSchema = zod.z.object({
-  id: zod.z.string().min(1),
-  kind: zod.z.enum(["skill", "concept", "product_step"]),
-  name: zod.z.string().min(1),
-  concept_codes: zod.z.array(zod.z.string()).default([]),
-  keywords: FeedKeywordsSchema,
-  estimated_minutes: zod.z.number().int().nonnegative(),
-  bloom_hint: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]).nullable().default(null),
-  depth_hint: zod.z.enum(["ulo", "cio", "sio"]).nullable().default(null),
-  completion_level: zod.z.enum(["mvp", "standard", "stretch"]).default("standard"),
-  scaffolding: zod.z.object({
-    scaffold_candidates: zod.z.array(FeedScaffoldCandidateSchema).default([]),
-    core_value_minutes: zod.z.number().int().nonnegative().default(0)
-  }).default({ scaffold_candidates: [], core_value_minutes: 0 }),
-  references: zod.z.array(zod.z.object({ file: zod.z.string().min(1), evidence: zod.z.string().default("") })).default([]),
-  feature_id: zod.z.string().nullable().default(null),
-  concept_ref: zod.z.string().nullable().default(null),
-  // Progressive-completion bookkeeping (feed v2, additive):
-  // phase_id = development phase that introduces/uses this node;
-  // introduce_aspect = how the phase teaches a concept node (first intro vs advanced revisit).
-  phase_id: zod.z.string().default(""),
-  introduce_aspect: zod.z.enum(["new", "advanced"]).nullable().default(null)
-});
-var FeedEdgeSchema = zod.z.object({
-  from: zod.z.string().min(1),
-  to: zod.z.string().min(1),
-  kind: zod.z.enum(["knowledge", "task"]),
-  reason: zod.z.string().default("")
-});
-var FeedGroupingSchema = zod.z.object({
-  id: zod.z.string().min(1),
-  name: zod.z.string().min(1),
-  node_ids: zod.z.array(zod.z.string()).min(1),
-  rationale: zod.z.string().default("")
-});
-var FeedPhaseSchema = zod.z.object({
-  id: zod.z.string().min(1),
-  order: zod.z.number().int().positive(),
-  name: zod.z.string().min(1),
-  product_completion: zod.z.string().min(1),
-  node_ids: zod.z.array(zod.z.string()).min(1)
-});
-var CurriculumFeedSchema = zod.z.object({
-  schema_version: zod.z.literal(2),
-  source: zod.z.object({
-    graph_type: zod.z.enum(["project_graph", "knowledge_graph", "hybrid_graph"]),
-    warnings: zod.z.array(zod.z.string()).default([]),
-    hallucination_count: zod.z.number().int().nonnegative().default(0)
-  }),
-  learning_nodes: zod.z.array(FeedNodeSchema).min(1, "curriculum feed must contain at least one learning node"),
-  dependency_edges: zod.z.array(FeedEdgeSchema).default([]),
-  suggested_groupings: zod.z.array(FeedGroupingSchema).default([]),
-  // Progressive completion phases (cross-feature). When non-empty, these — not
-  // suggested_groupings — define the teaching sequence and unit structure.
-  phases: zod.z.array(FeedPhaseSchema).default([])
-});
-function validateCurriculumFeed(feed) {
-  const parsed = CurriculumFeedSchema.parse(feed);
-  const ids = new Set(parsed.learning_nodes.map((n) => n.id));
-  if (ids.size !== parsed.learning_nodes.length) {
-    throw new Error("curriculum feed contains duplicate node ids");
-  }
-  for (const e of parsed.dependency_edges) {
-    if (!ids.has(e.from) || !ids.has(e.to)) {
-      throw new Error("curriculum feed edge " + e.from + " -> " + e.to + " references unknown node");
-    }
-    if (e.from === e.to) throw new Error("curriculum feed self-loop edge on " + e.from);
-  }
-  for (const g of parsed.suggested_groupings) {
-    for (const id of g.node_ids) {
-      if (!ids.has(id)) throw new Error("grouping " + g.id + " references unknown node " + id);
-    }
-  }
-  for (const ph of parsed.phases) {
-    for (const id of ph.node_ids) {
-      if (!ids.has(id)) throw new Error("phase " + ph.id + " references unknown node " + id);
-    }
-  }
-  const phaseIds = parsed.phases.map((p) => p.id);
-  if (new Set(phaseIds).size !== phaseIds.length) throw new Error("curriculum feed contains duplicate phase ids");
-  return parsed;
-}
+
+// src/schemas/index.ts
+init_curriculumFeedSchema();
 
 // src/parsers/swift.ts
 var IMPORT_RE = /^import\s+(\w+)/gm;
@@ -921,6 +1361,190 @@ function mergeCppResults(results) {
   return merged;
 }
 
+// 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/extractors/keywordExtractor.ts
 var STDLIB_MODULES = /* @__PURE__ */ new Set([
   // Python
@@ -2128,11 +2752,15 @@ function detectLearningMode(options) {
 
 // src/detector/domainProfileDetector.ts
 function detectDomainProfile(options) {
-  const inputResult = detectInputType(options);
+  const effectiveSyllabus = options.syllabusText || options.parsedSyllabus?.rawText || "";
+  const inputResult = detectInputType({
+    ...options,
+    syllabusText: effectiveSyllabus
+  });
   const domainResult = detectDomain({
     description: options.description,
     goal: options.goal,
-    syllabusText: options.syllabusText,
+    syllabusText: effectiveSyllabus,
     techStack: options.techStack,
     fileExtensions: options.fileExtensions,
     repoUrl: options.repoUrl
@@ -2143,12 +2771,12 @@ function detectDomainProfile(options) {
     goal: options.goal,
     description: options.description,
     hasRepo: !!(options.repoUrl || options.repoDir),
-    hasSyllabus: !!(options.syllabusText || options.chapters && options.chapters.length > 0)
+    hasSyllabus: !!(effectiveSyllabus || options.chapters && options.chapters.length > 0 || options.parsedSyllabus)
   });
   const graphType = determineGraphType(modeResult.learningMode);
   return {
     inputType: inputResult.inputType,
-    domainCategory: domainResult.domainCategory,
+    domainCategory: domainResult.domainCategory === "other" && options.parsedSyllabus?.subject.domain ? options.parsedSyllabus.subject.domain : domainResult.domainCategory,
     learningMode: modeResult.learningMode,
     graphType,
     confidence: {
@@ -2158,13 +2786,13 @@ function detectDomainProfile(options) {
     },
     evidence: [...inputResult.evidence, ...domainResult.evidence, ...modeResult.evidence],
     detectedTechStack: domainResult.detectedTechStack,
-    detectedSubject: domainResult.detectedSubject,
+    detectedSubject: options.parsedSyllabus?.subject.title || domainResult.detectedSubject,
     detectedDomain: domainResult.domainCategory,
     goal: options.goal || "",
     description: options.description || "",
     repoUrl: options.repoUrl || "",
     repoDir: options.repoDir || "",
-    syllabusText: options.syllabusText || ""
+    syllabusText: effectiveSyllabus
   };
 }
 function determineGraphType(learningMode) {
@@ -3144,6 +3772,161 @@ 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/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)
@@ -3741,58 +4524,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();
@@ -3833,6 +4564,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 = "";
@@ -3844,10 +4580,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}` : ""}
@@ -3992,13 +4731,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) {
@@ -4049,16 +4788,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
   };
 }
 
@@ -4438,562 +5182,246 @@ async function resolveConcepts(options) {
     const effThreshold = SOURCE_THRESHOLDS[source] || threshold;
     const topMatch = topMatches[0];
     if (topMatch.score >= effThreshold) {
-      resolved.push({
-        keyword,
-        source,
-        depth,
-        concept_codes: topMatches.filter((m) => m.score >= effThreshold).map((m) => m.code),
-        matches: topMatches
-      });
-    } else {
-      proposed.push({
-        keyword,
-        source,
-        depth,
-        best_match: topMatch,
-        reason: `Low confidence (${topMatch.score.toFixed(2)} < ${effThreshold})`
-      });
-    }
-  }
-  return {
-    resolved,
-    proposed,
-    summary: {
-      total_keywords: keywords.length,
-      resolved_count: resolved.length,
-      proposed_count: proposed.length,
-      search_mode
-    }
-  };
-}
-
-// src/assembly/roadmapAssembler.ts
-function calculateOverhead(rawMinutes, overheadFactor) {
-  return Math.ceil(rawMinutes * overheadFactor);
-}
-function splitFeatureIntoMilestones(feature, featureConcepts, maxMinutes, overheadFactor) {
-  const steps = feature.steps || [];
-  if (steps.length === 0) return [];
-  const featureId = feature.id || "F_UNK";
-  const stepMinutes2 = steps.map((s) => s.effort?.estimated_minutes || 15);
-  const totalRawMinutes = stepMinutes2.reduce((a, b) => a + b, 0);
-  if (calculateOverhead(totalRawMinutes, overheadFactor) <= maxMinutes) {
-    return [buildMilestone(feature, featureConcepts, steps, stepMinutes2, featureId, 1)];
-  }
-  const milestones = [];
-  let currentSteps = [];
-  let currentMinutes = [];
-  let milestoneIndex = 1;
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    const mins = stepMinutes2[i];
-    const currentTotal = currentMinutes.reduce((a, b) => a + b, 0);
-    if (calculateOverhead(currentTotal + mins, overheadFactor) > maxMinutes && currentSteps.length > 0) {
-      milestones.push(buildMilestone(
-        feature,
-        featureConcepts,
-        currentSteps,
-        currentMinutes,
-        featureId,
-        milestoneIndex
-      ));
-      milestoneIndex++;
-      currentSteps = [];
-      currentMinutes = [];
-    }
-    currentSteps.push(step);
-    currentMinutes.push(mins);
-  }
-  if (currentSteps.length > 0) {
-    milestones.push(buildMilestone(
-      feature,
-      featureConcepts,
-      currentSteps,
-      currentMinutes,
-      featureId,
-      milestoneIndex
-    ));
-  }
-  return milestones;
-}
-function buildMilestone(feature, featureConcepts, steps, stepMinutes2, featureId, milestoneIndex) {
-  const rawMinutes = stepMinutes2.reduce((a, b) => a + b, 0);
-  const levels = steps.map((s) => s.completion_level || "mvp");
-  const completionLevel = levels.includes("extend") ? "extend" : levels.includes("mvp") ? "mvp" : "base";
-  const milestoneConcepts = /* @__PURE__ */ new Set();
-  const milestoneKeywords = /* @__PURE__ */ new Set();
-  for (const step of steps) {
-    const stepConceptCodes = step.concept_codes || [];
-    for (const code of stepConceptCodes) {
-      milestoneConcepts.add(code);
-    }
-    const stepKws = [...step.keywords || [], ...step.api_usage || []];
-    for (const cm of featureConcepts) {
-      if (stepKws.includes(cm.keyword)) {
-        milestoneConcepts.add(cm.concept_code);
-        milestoneKeywords.add(cm.keyword);
-      }
-    }
-  }
-  const depthCounts = { ulo: 0, cio: 0, sio: 0 };
-  for (const cm of featureConcepts) {
-    if (milestoneKeywords.has(cm.keyword)) {
-      depthCounts[cm.depth]++;
-    }
-  }
-  const dominantDepth = depthCounts.sio >= depthCounts.cio && depthCounts.sio >= depthCounts.ulo ? "sio" : depthCounts.cio >= depthCounts.ulo ? "cio" : "ulo";
-  return {
-    id: milestoneIndex === 1 ? featureId : `${featureId}-M${milestoneIndex}`,
-    name: milestoneIndex === 1 ? feature.name || featureId : `${feature.name || featureId} (Part ${milestoneIndex})`,
-    description: feature.description || "",
-    feature_id: featureId,
-    feature_name: feature.name || "",
-    concept_code: [...milestoneConcepts].join(", "),
-    depth: dominantDepth,
-    all_keywords: [],
-    new_keywords: [],
-    prerequisite_keywords: [],
-    steps,
-    estimated_minutes: rawMinutes,
-    adjusted_minutes: rawMinutes,
-    // placeholder — assembleRoadmap() applies actual overheadFactor
-    completion_level: completionLevel
-  };
-}
-function buildKeywordMap(featureConcepts) {
-  const map = /* @__PURE__ */ new Map();
-  for (const mappings of featureConcepts.values()) {
-    for (const m of mappings) {
-      const existing = map.get(m.concept_code) || [];
-      if (!existing.includes(m.keyword)) {
-        existing.push(m.keyword);
-        map.set(m.concept_code, existing);
-      }
-    }
-  }
-  return map;
-}
-function attachKeywordsToMilestones(milestones, keywordMap) {
-  const cumulativeKeywords = /* @__PURE__ */ new Set();
-  for (const milestone of milestones) {
-    const allKw = /* @__PURE__ */ new Set();
-    const conceptCodes = milestone.concept_code.split(",").map((c) => c.trim()).filter(Boolean);
-    for (const code of conceptCodes) {
-      const kws = keywordMap.get(code) || [];
-      for (const kw of kws) allKw.add(kw);
-    }
-    milestone.all_keywords = Array.from(allKw).sort();
-    const newKw = [];
-    const prereqKw = [];
-    for (const kw of milestone.all_keywords) {
-      if (cumulativeKeywords.has(kw)) {
-        prereqKw.push(kw);
-      } else {
-        newKw.push(kw);
-        cumulativeKeywords.add(kw);
-      }
-    }
-    milestone.new_keywords = newKw;
-    milestone.prerequisite_keywords = prereqKw;
-  }
-  return milestones;
-}
-function groupIntoPhases(milestones, sessionMinutes) {
-  const phases = [];
-  let currentMilestones = [];
-  let currentMinutes = 0;
-  let phaseNum = 1;
-  for (const milestone of milestones) {
-    const milestoneMinutes = milestone.adjusted_minutes;
-    if (currentMinutes + milestoneMinutes > sessionMinutes && currentMilestones.length > 0) {
-      phases.push(buildPhase(currentMilestones, phaseNum));
-      phaseNum++;
-      currentMilestones = [];
-      currentMinutes = 0;
-    }
-    currentMilestones.push(milestone);
-    currentMinutes += milestoneMinutes;
-  }
-  if (currentMilestones.length > 0) {
-    phases.push(buildPhase(currentMilestones, phaseNum));
-  }
-  return phases;
-}
-function buildPhase(milestones, phaseNum) {
-  const totalMinutes = milestones.reduce((sum, m) => sum + m.adjusted_minutes, 0);
-  const depths = milestones.map((m) => m.depth);
-  const uniqueDepths = [...new Set(depths)];
-  const progression = uniqueDepths.map((d) => d.toUpperCase()).join(" \u2192 ");
-  return {
-    phase_id: phaseNum,
-    phase_name: `Phase ${phaseNum}`,
-    milestones,
-    total_minutes: totalMinutes,
-    concept_progression: progression
-  };
-}
-function assembleRoadmap(options) {
-  const {
-    projectGraph,
-    featureConcepts = /* @__PURE__ */ new Map(),
-    sessionMinutes = 90,
-    overheadFactor = 1.15,
-    maxMilestoneMinutes = 120
-  } = options;
-  const features = projectGraph.features || [];
-  const keywordMap = buildKeywordMap(featureConcepts);
-  const allMilestones = [];
-  for (const feature of features) {
-    const fid = feature.id || "F_UNK";
-    const fConcepts = featureConcepts.get(fid) || [];
-    const milestones = splitFeatureIntoMilestones(
-      feature,
-      fConcepts,
-      maxMilestoneMinutes,
-      overheadFactor
-    );
-    allMilestones.push(...milestones);
-  }
-  for (const milestone of allMilestones) {
-    milestone.adjusted_minutes = calculateOverhead(milestone.estimated_minutes, overheadFactor);
-  }
-  attachKeywordsToMilestones(allMilestones, keywordMap);
-  const phases = groupIntoPhases(allMilestones, sessionMinutes);
-  const totalEstimatedMinutes = allMilestones.reduce((sum, m) => sum + m.estimated_minutes, 0);
-  const totalAdjustedMinutes = allMilestones.reduce((sum, m) => sum + m.adjusted_minutes, 0);
-  return {
-    project: projectGraph.project,
-    product: projectGraph.product,
-    phases,
-    feature_concepts: featureConcepts,
-    time_budget: {
-      session_minutes: sessionMinutes,
-      overhead_factor: overheadFactor,
-      total_estimated_minutes: totalEstimatedMinutes,
-      total_adjusted_minutes: totalAdjustedMinutes
-    }
-  };
-}
-
-// src/feed/curriculumFeedEmitter.ts
-var BLOOM_RANK = { Remember: 0, Understand: 1, Apply: 2, Analyze: 3, Evaluate: 4, Create: 5 };
-var pad22 = (n) => String(n).padStart(2, "0");
-var arr = (v) => Array.isArray(v) ? v : [];
-var str = (v, d = "") => typeof v === "string" ? v : d;
-var num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
-var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
-function stepMinutes(step) {
-  const effort = step.effort ?? {};
-  return Math.max(0, Math.round(num(effort.estimated_minutes, num(step.estimated_minutes, 45))));
-}
-function newKeywordsInOrder(nodes) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const n of nodes) {
-    const all = n.keywords.all;
-    n.keywords.new = [];
-    n.keywords.prerequisite = [];
-    for (const k of all) {
-      if (seen.has(k)) n.keywords.prerequisite.push(k);
-      else n.keywords.new.push(k);
-      seen.add(k);
+      resolved.push({
+        keyword,
+        source,
+        depth,
+        concept_codes: topMatches.filter((m) => m.score >= effThreshold).map((m) => m.code),
+        matches: topMatches
+      });
+    } else {
+      proposed.push({
+        keyword,
+        source,
+        depth,
+        best_match: topMatch,
+        reason: `Low confidence (${topMatch.score.toFixed(2)} < ${effThreshold})`
+      });
     }
   }
-}
-function feedNodeFromStep(step, featureId) {
-  const id = str(step.id);
-  return {
-    id,
-    kind: "product_step",
-    name: str(step.name, id),
-    concept_codes: strs(step.concept_codes),
-    keywords: { all: strs(step.keywords), new: [], prerequisite: [] },
-    estimated_minutes: stepMinutes(step),
-    bloom_hint: "Apply",
-    depth_hint: null,
-    completion_level: "standard",
-    scaffolding: { scaffold_candidates: [], core_value_minutes: stepMinutes(step) },
-    references: arr(step.files).map((f) => ({ file: str(f), evidence: "step file" })).filter((f) => f.file),
-    feature_id: featureId,
-    concept_ref: null,
-    phase_id: "",
-    introduce_aspect: null
-  };
-}
-function feedNodeFromConcept(concept) {
-  const id = str(concept.id);
-  const pts = arr(concept.problem_types).map((p) => str(p.bloom_level, "Understand")).filter((b) => b in BLOOM_RANK).sort((a, b) => BLOOM_RANK[a] - BLOOM_RANK[b]);
-  const topBloom = pts[pts.length - 1] ?? "Understand";
   return {
-    id,
-    kind: "concept",
-    name: str(concept.name, id),
-    concept_codes: [str(concept.code) || id].filter(Boolean),
-    keywords: { all: strs(concept.keywords), new: [], prerequisite: [] },
-    estimated_minutes: Math.max(0, Math.round(num(concept.estimated_minutes, 30))),
-    bloom_hint: topBloom,
-    depth_hint: null,
-    completion_level: "standard",
-    scaffolding: { scaffold_candidates: [], core_value_minutes: 0 },
-    references: [],
-    feature_id: null,
-    concept_ref: id,
-    phase_id: "",
-    introduce_aspect: null
+    resolved,
+    proposed,
+    summary: {
+      total_keywords: keywords.length,
+      resolved_count: resolved.length,
+      proposed_count: proposed.length,
+      search_mode
+    }
   };
 }
-function addFeatureGroup(f, fid, nodes, edges, groupings) {
-  const steps = arr(f.steps);
-  const stepIds = [];
-  let prev = "";
-  for (let i = 0; i < steps.length; i++) {
-    const stepNode = feedNodeFromStep(steps[i], fid);
-    if (!stepNode.id) continue;
-    stepIds.push(stepNode.id);
-    nodes.push(stepNode);
-    if (prev) edges.push({ from: prev, to: stepNode.id, kind: "task", reason: "feature build order" });
-    prev = stepNode.id;
-  }
-  for (const dep of strs(f.depends_on)) {
-    const depFirst = nodes.find((n) => n.feature_id === dep);
-    if (depFirst && stepIds[0]) edges.push({ from: depFirst.id, to: stepIds[0], kind: "task", reason: "feature depends_on " + dep });
-  }
-  if (stepIds.length > 0) groupings.push({ id: "G-" + fid, name: str(f.name, fid), node_ids: stepIds, rationale: str(f.description, "") });
-  return stepIds;
+
+// src/assembly/roadmapAssembler.ts
+function calculateOverhead(rawMinutes, overheadFactor) {
+  return Math.ceil(rawMinutes * overheadFactor);
 }
-function emitFromHybrid(hybrid, opts) {
-  const nodes = [];
-  const edges = [];
-  const groupings = [];
-  const pg = hybrid.project_graph ?? {};
-  const kg = hybrid.knowledge_graph ?? {};
-  const rawPhases = arr(hybrid.phases).filter((p) => str(p.id));
-  const features = arr(pg.features);
-  const conceptRecs = arr(kg.concepts);
-  const conceptById = new Map(conceptRecs.map((c) => [str(c.id), c]));
-  if (rawPhases.length === 0) {
-    for (const c of conceptRecs) {
-      const node = feedNodeFromConcept(c);
-      nodes.push(node);
-      for (const p of strs(c.prerequisites)) edges.push({ from: p, to: node.id, kind: "knowledge", reason: "concept prerequisite" });
-    }
-    features.forEach((f, fi) => addFeatureGroup(f, str(f.id, "F" + pad22(fi + 1)), nodes, edges, groupings));
-    linkHybridKnowledgeEdges(hybrid, nodes, edges);
-    newKeywordsInOrder(nodes);
-    return validateCurriculumFeed({
-      schema_version: 2,
-      source: { graph_type: "hybrid_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
-      learning_nodes: nodes,
-      dependency_edges: edges,
-      suggested_groupings: groupings,
-      phases: []
-    });
-  }
-  const featureOrder = /* @__PURE__ */ new Map();
-  features.forEach((f, fi) => featureOrder.set(str(f.id, "F" + pad22(fi + 1)), fi));
-  const stepIdsByFeature = /* @__PURE__ */ new Map();
-  for (const f of features) {
-    const fid = str(f.id);
-    stepIdsByFeature.set(fid, arr(f.steps).map((s) => str(s.id)).filter(Boolean));
-  }
-  const emitCtx = [];
-  const emittedConcepts = /* @__PURE__ */ new Set();
-  const linkList = arr(hybrid.links);
-  for (const rp of rawPhases) {
-    const pid = str(rp.id);
-    const order = num(rp.order, emitCtx.length + 1);
-    const conceptOrder = [];
-    const intros = arr(rp.introduces);
-    const news = intros.filter((i) => str(i.aspect, "new") === "new");
-    const advanced = intros.filter((i) => str(i.aspect) === "advanced");
-    for (const intro of [...news, ...advanced]) {
-      const cid = str(intro.concept_id);
-      const c = conceptById.get(cid);
-      if (!c) {
-        throw new Error("Phase " + pid + " introduces unknown concept " + cid + " - fail-closed");
-      }
-      if (str(intro.aspect, "new") === "advanced" && !emittedConcepts.has(cid)) {
-        throw new Error("Phase " + pid + " advanced-revisits concept " + cid + " that was never emitted - fail-closed");
-      }
-      if (!emittedConcepts.has(cid)) {
-        const node = feedNodeFromConcept(c);
-        node.phase_id = pid;
-        node.introduce_aspect = "new";
-        nodes.push(node);
-        for (const p of strs(c.prerequisites)) {
-          if (!emittedConcepts.has(p)) {
-            throw new Error("Concept " + cid + " (phase " + pid + ") has prerequisite " + p + " that is not introduced in an earlier phase - fail-closed");
-          }
-          edges.push({ from: p, to: cid, kind: "knowledge", reason: "concept prerequisite" });
-        }
-        emittedConcepts.add(cid);
-        conceptOrder.push(cid);
-      } else {
-        const revisitId = cid + "__ADV" + pad22(order);
-        const node = feedNodeFromConcept(c);
-        node.id = revisitId;
-        node.name = str(c.name, cid) + " (advanced)";
-        node.phase_id = pid;
-        node.introduce_aspect = "advanced";
-        node.estimated_minutes = Math.max(15, Math.round(node.estimated_minutes * 0.5));
-        node.concept_codes = [str(c.code) || cid];
-        edges.push({ from: cid, to: revisitId, kind: "knowledge", reason: "advanced revisit of " + cid + " at phase " + pid });
-        nodes.push(node);
-        conceptOrder.push(revisitId);
-      }
-    }
-    const featureIds = strs(rp.feature_ids).filter((fid) => featureOrder.has(fid)).sort((a, b) => featureOrder.get(a) - featureOrder.get(b));
-    emitCtx.push({ id: pid, order, name: str(rp.name, pid), productCompletion: str(rp.product_completion), conceptOrder, featureIds });
+function splitFeatureIntoMilestones(feature, featureConcepts, maxMinutes, overheadFactor) {
+  const steps = feature.steps || [];
+  if (steps.length === 0) return [];
+  const featureId = feature.id || "F_UNK";
+  const stepMinutes2 = steps.map((s) => s.effort?.estimated_minutes || 15);
+  const totalRawMinutes = stepMinutes2.reduce((a, b) => a + b, 0);
+  if (calculateOverhead(totalRawMinutes, overheadFactor) <= maxMinutes) {
+    return [buildMilestone(feature, featureConcepts, steps, stepMinutes2, featureId, 1)];
   }
-  for (const l of linkList) {
-    const cid = str(l.concept_id);
-    if (cid && conceptById.has(cid) && !emittedConcepts.has(cid)) {
-      throw new Error("Concept " + cid + " is consumed by links but never introduced in any phase - fail-closed");
+  const milestones = [];
+  let currentSteps = [];
+  let currentMinutes = [];
+  let milestoneIndex = 1;
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const mins = stepMinutes2[i];
+    const currentTotal = currentMinutes.reduce((a, b) => a + b, 0);
+    if (calculateOverhead(currentTotal + mins, overheadFactor) > maxMinutes && currentSteps.length > 0) {
+      milestones.push(buildMilestone(
+        feature,
+        featureConcepts,
+        currentSteps,
+        currentMinutes,
+        featureId,
+        milestoneIndex
+      ));
+      milestoneIndex++;
+      currentSteps = [];
+      currentMinutes = [];
     }
+    currentSteps.push(step);
+    currentMinutes.push(mins);
   }
-  const seenFeatures = new Set(emitCtx.flatMap((e) => e.featureIds));
-  const missingFeatures = features.map((f) => str(f.id)).filter((fid) => fid && !seenFeatures.has(fid));
-  if (missingFeatures.length > 0) {
-    throw new Error("Features not covered by any phase: " + missingFeatures.join(", ") + " - fail-closed");
+  if (currentSteps.length > 0) {
+    milestones.push(buildMilestone(
+      feature,
+      featureConcepts,
+      currentSteps,
+      currentMinutes,
+      featureId,
+      milestoneIndex
+    ));
   }
-  const phaseNodeIds = [];
-  for (const ctx of emitCtx) {
-    const ids = [...ctx.conceptOrder];
-    for (const fid of ctx.featureIds) {
-      const f = features.find((x) => str(x.id) === fid);
-      const stepIds = addFeatureGroup(f, fid, nodes, edges, groupings);
-      for (const sid of stepIds) {
-        const node = nodes.find((n) => n.id === sid);
-        node.phase_id = ctx.id;
-      }
-      ids.push(...stepIds);
+  return milestones;
+}
+function buildMilestone(feature, featureConcepts, steps, stepMinutes2, featureId, milestoneIndex) {
+  const rawMinutes = stepMinutes2.reduce((a, b) => a + b, 0);
+  const levels = steps.map((s) => s.completion_level || "mvp");
+  const completionLevel = levels.includes("extend") ? "extend" : levels.includes("mvp") ? "mvp" : "base";
+  const milestoneConcepts = /* @__PURE__ */ new Set();
+  const milestoneKeywords = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    const stepConceptCodes = step.concept_codes || [];
+    for (const code of stepConceptCodes) {
+      milestoneConcepts.add(code);
     }
-    phaseNodeIds.push(ids);
-  }
-  const edgeSeen = new Set(edges.map((e) => e.from + ">" + e.to));
-  const pushEdge = (from, to, reason) => {
-    const key = from + ">" + to;
-    if (edgeSeen.has(key)) return;
-    edgeSeen.add(key);
-    edges.push({ from, to, kind: "knowledge", reason });
-  };
-  for (const l of linkList) {
-    const cid = str(l.concept_id);
-    const fid = str(l.feature_id);
-    if (!conceptById.has(cid)) continue;
-    const firstStep = (stepIdsByFeature.get(fid) || [])[0];
-    if (!firstStep) continue;
-    const depth = str(l.depth, "cio");
-    pushEdge(cid, firstStep, str(l.relationship, "hybrid link") + " [" + depth + "]");
-    for (const n of nodes) {
-      if (n.kind === "concept" && n.concept_ref === cid && n.introduce_aspect === "advanced" && n.phase_id === str(l.phase_id)) {
-        pushEdge(n.id, firstStep, "advanced application [" + depth + "]");
+    const stepKws = [...step.keywords || [], ...step.api_usage || []];
+    for (const cm of featureConcepts) {
+      if (stepKws.includes(cm.keyword)) {
+        milestoneConcepts.add(cm.concept_code);
+        milestoneKeywords.add(cm.keyword);
       }
     }
   }
-  newKeywordsInOrder(nodes);
-  const feedOrder = new Map(nodes.map((n, i) => [n.id, i]));
-  const introducer = /* @__PURE__ */ new Map();
-  for (const n of nodes) for (const k of n.keywords?.new ?? []) {
-    const key = k.toLowerCase();
-    if (!introducer.has(key)) introducer.set(key, n.id);
+  const depthCounts = { ulo: 0, cio: 0, sio: 0 };
+  for (const cm of featureConcepts) {
+    if (milestoneKeywords.has(cm.keyword)) {
+      depthCounts[cm.depth]++;
+    }
   }
-  for (const n of nodes) {
-    for (const k of n.keywords?.prerequisite ?? []) {
-      const src = introducer.get(k.toLowerCase());
-      if (!src || src === n.id) continue;
-      if (feedOrder.get(src) < feedOrder.get(n.id)) pushEdge(src, n.id, "keyword prerequisite [" + k + "]");
+  const dominantDepth = depthCounts.sio >= depthCounts.cio && depthCounts.sio >= depthCounts.ulo ? "sio" : depthCounts.cio >= depthCounts.ulo ? "cio" : "ulo";
+  return {
+    id: milestoneIndex === 1 ? featureId : `${featureId}-M${milestoneIndex}`,
+    name: milestoneIndex === 1 ? feature.name || featureId : `${feature.name || featureId} (Part ${milestoneIndex})`,
+    description: feature.description || "",
+    feature_id: featureId,
+    feature_name: feature.name || "",
+    concept_code: [...milestoneConcepts].join(", "),
+    depth: dominantDepth,
+    all_keywords: [],
+    new_keywords: [],
+    prerequisite_keywords: [],
+    steps,
+    estimated_minutes: rawMinutes,
+    adjusted_minutes: rawMinutes,
+    // placeholder — assembleRoadmap() applies actual overheadFactor
+    completion_level: completionLevel
+  };
+}
+function buildKeywordMap(featureConcepts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const mappings of featureConcepts.values()) {
+    for (const m of mappings) {
+      const existing = map.get(m.concept_code) || [];
+      if (!existing.includes(m.keyword)) {
+        existing.push(m.keyword);
+        map.set(m.concept_code, existing);
+      }
     }
   }
-  const phases = emitCtx.map((ctx, i) => ({
-    id: ctx.id,
-    order: ctx.order,
-    name: ctx.name,
-    product_completion: ctx.productCompletion || "Phase " + (i + 1) + " deliverable",
-    node_ids: phaseNodeIds[i]
-  }));
-  return validateCurriculumFeed({
-    schema_version: 2,
-    source: { graph_type: "hybrid_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
-    learning_nodes: nodes,
-    dependency_edges: edges,
-    suggested_groupings: groupings,
-    phases
-  });
+  return map;
 }
-function linkHybridKnowledgeEdges(hybrid, nodes, edges, setStepHints) {
-  const conceptIds = new Set(nodes.filter((n) => n.kind === "concept").map((n) => n.concept_ref || n.id));
-  for (const l of arr(hybrid.links)) {
-    const conceptId = str(l.concept_id);
-    const featureId = str(l.feature_id);
-    if (!conceptIds.has(conceptId)) continue;
-    const depth = str(l.depth, "cio");
-    const firstStep = nodes.find((n) => n.feature_id === featureId);
-    if (firstStep) {
-      edges.push({ from: conceptId, to: firstStep.id, kind: "knowledge", reason: str(l.relationship, "hybrid link") + " [" + depth + "]" });
-      if (!firstStep.depth_hint) {
-        firstStep.depth_hint = ["ulo", "cio", "sio"].includes(depth) ? depth : "cio";
+function attachKeywordsToMilestones(milestones, keywordMap) {
+  const cumulativeKeywords = /* @__PURE__ */ new Set();
+  for (const milestone of milestones) {
+    const allKw = /* @__PURE__ */ new Set();
+    const conceptCodes = milestone.concept_code.split(",").map((c) => c.trim()).filter(Boolean);
+    for (const code of conceptCodes) {
+      const kws = keywordMap.get(code) || [];
+      for (const kw of kws) allKw.add(kw);
+    }
+    milestone.all_keywords = Array.from(allKw).sort();
+    const newKw = [];
+    const prereqKw = [];
+    for (const kw of milestone.all_keywords) {
+      if (cumulativeKeywords.has(kw)) {
+        prereqKw.push(kw);
+      } else {
+        newKw.push(kw);
+        cumulativeKeywords.add(kw);
       }
     }
+    milestone.new_keywords = newKw;
+    milestone.prerequisite_keywords = prereqKw;
   }
+  return milestones;
 }
-function emitFromKnowledge(kg, opts) {
-  const nodes = [];
-  const edges = [];
-  const groupings = [];
-  for (const c of arr(kg.concepts)) {
-    const node = feedNodeFromConcept(c);
-    nodes.push(node);
-    for (const p of strs(c.prerequisites)) edges.push({ from: p, to: node.id, kind: "knowledge", reason: "concept prerequisite" });
+function groupIntoPhases(milestones, sessionMinutes) {
+  const phases = [];
+  let currentMilestones = [];
+  let currentMinutes = 0;
+  let phaseNum = 1;
+  for (const milestone of milestones) {
+    const milestoneMinutes = milestone.adjusted_minutes;
+    if (currentMinutes + milestoneMinutes > sessionMinutes && currentMilestones.length > 0) {
+      phases.push(buildPhase(currentMilestones, phaseNum));
+      phaseNum++;
+      currentMilestones = [];
+      currentMinutes = 0;
+    }
+    currentMilestones.push(milestone);
+    currentMinutes += milestoneMinutes;
   }
-  let ci = 0;
-  for (const cat of arr(kg.categories)) {
-    ci += 1;
-    const ids = strs(cat.concept_ids).filter((id) => nodes.some((n) => n.id === id));
-    if (ids.length > 0) groupings.push({ id: str(cat.id, "cat" + ci), name: str(cat.name, "Category " + ci), node_ids: ids, rationale: str(cat.description, "") });
+  if (currentMilestones.length > 0) {
+    phases.push(buildPhase(currentMilestones, phaseNum));
   }
-  newKeywordsInOrder(nodes);
-  return validateCurriculumFeed({
-    schema_version: 2,
-    source: { graph_type: "knowledge_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
-    learning_nodes: nodes,
-    dependency_edges: edges,
-    suggested_groupings: groupings,
-    phases: []
-  });
+  return phases;
 }
-function emitFromProject(pg, opts) {
-  const nodes = [];
-  const edges = [];
-  const groupings = [];
-  arr(pg.features).forEach((f, fi) => addFeatureGroup(f, str(f.id, "F" + pad22(fi + 1)), nodes, edges, groupings));
-  if (nodes.length === 0 && arr(pg.features).length > 0) {
-    const hasTasks = arr(pg.implementation ?? {}).length > 0 || arr(pg.implementation?.tasks).length > 0;
-    throw new Error(
-      "Project graph has " + arr(pg.features).length + " features but NO features[].steps - the curriculum feed cannot emit planning nodes." + (hasTasks ? " This looks like a legacy knowledge-tree graph (implementation.tasks). Regenerate it with the domain-kit v3 pipeline (runProjectGraphPipeline / hybridGraphPipeline), then re-run." : " Every feature must carry at least one step with id/name/keywords/effort for curriculum planning.")
-    );
-  }
-  newKeywordsInOrder(nodes);
-  return validateCurriculumFeed({
-    schema_version: 2,
-    source: { graph_type: "project_graph", warnings: opts.warnings ?? [], hallucination_count: opts.hallucinationCount ?? 0 },
-    learning_nodes: nodes,
-    dependency_edges: edges,
-    suggested_groupings: groupings,
-    phases: []
-  });
+function buildPhase(milestones, phaseNum) {
+  const totalMinutes = milestones.reduce((sum, m) => sum + m.adjusted_minutes, 0);
+  const depths = milestones.map((m) => m.depth);
+  const uniqueDepths = [...new Set(depths)];
+  const progression = uniqueDepths.map((d) => d.toUpperCase()).join(" \u2192 ");
+  return {
+    phase_id: phaseNum,
+    phase_name: `Phase ${phaseNum}`,
+    milestones,
+    total_minutes: totalMinutes,
+    concept_progression: progression
+  };
 }
-function emitCurriculumFeed(graph, opts = {}) {
-  const g = graph;
-  if (arr(g.learning_nodes).length > 0) {
-    return validateCurriculumFeed(g);
+function assembleRoadmap(options) {
+  const {
+    projectGraph,
+    featureConcepts = /* @__PURE__ */ new Map(),
+    sessionMinutes = 90,
+    overheadFactor = 1.15,
+    maxMilestoneMinutes = 120
+  } = options;
+  const features = projectGraph.features || [];
+  const keywordMap = buildKeywordMap(featureConcepts);
+  const allMilestones = [];
+  for (const feature of features) {
+    const fid = feature.id || "F_UNK";
+    const fConcepts = featureConcepts.get(fid) || [];
+    const milestones = splitFeatureIntoMilestones(
+      feature,
+      fConcepts,
+      maxMilestoneMinutes,
+      overheadFactor
+    );
+    allMilestones.push(...milestones);
   }
-  if (g.project_graph || g.knowledge_graph || arr(g.links).length > 0 || arr(g.phases).length > 0) {
-    return emitFromHybrid(g, opts);
+  for (const milestone of allMilestones) {
+    milestone.adjusted_minutes = calculateOverhead(milestone.estimated_minutes, overheadFactor);
   }
-  if (arr(g.concepts).length > 0 || str(g.type) === "knowledge_graph") return emitFromKnowledge(g, opts);
-  return emitFromProject(g, opts);
+  attachKeywordsToMilestones(allMilestones, keywordMap);
+  const phases = groupIntoPhases(allMilestones, sessionMinutes);
+  const totalEstimatedMinutes = allMilestones.reduce((sum, m) => sum + m.estimated_minutes, 0);
+  const totalAdjustedMinutes = allMilestones.reduce((sum, m) => sum + m.adjusted_minutes, 0);
+  return {
+    project: projectGraph.project,
+    product: projectGraph.product,
+    phases,
+    feature_concepts: featureConcepts,
+    time_budget: {
+      session_minutes: sessionMinutes,
+      overhead_factor: overheadFactor,
+      total_estimated_minutes: totalEstimatedMinutes,
+      total_adjusted_minutes: totalAdjustedMinutes
+    }
+  };
 }
 
+// src/feed/index.ts
+init_curriculumFeedEmitter();
+
 // src/extractors/fileSelector.ts
 async function selectFilesWithLlm(filePaths, goal, techStack, llmConfig) {
   if (filePaths.length <= 15) {
@@ -5427,6 +5855,174 @@ async function runProjectGraphPipeline(options) {
   };
 }
 
+// src/pipeline/knowledgeGraphPipeline.ts
+init_curriculumFeedEmitter();
+async function runKnowledgeGraphPipeline(options) {
+  const warnings = [];
+  let parsedSyllabus = options.parsedSyllabus;
+  if (!parsedSyllabus && options.syllabusText) {
+    parsedSyllabus = parseSyllabus(options.syllabusText);
+  }
+  const effectiveSubject = options.subject || parsedSyllabus?.subject.title || "Untitled Subject";
+  const effectiveDomain = options.domain || parsedSyllabus?.subject.domain || "other";
+  const effectiveGradeBand = options.gradeBand || parsedSyllabus?.subject.gradeBand;
+  const effectiveDesc = options.description || parsedSyllabus?.subject.description;
+  const result = await generateKnowledgeGraph({
+    ...options,
+    subject: effectiveSubject,
+    domain: effectiveDomain,
+    gradeBand: effectiveGradeBand,
+    description: effectiveDesc,
+    parsedSyllabus
+  });
+  warnings.push(...result.warnings);
+  const curriculumFeed = emitCurriculumFeed(result.knowledgeGraph, {
+    warnings
+  });
+  return {
+    knowledgeGraph: result.knowledgeGraph,
+    parsedSyllabus,
+    curriculumFeed,
+    verificationReport: result.verificationReport,
+    warnings
+  };
+}
+
+// src/pipeline/hybridGraphPipeline.ts
+init_curriculumFeedEmitter();
+async function runHybridGraphPipeline(options) {
+  const warnings = [];
+  const result = await generateHybridGraph(options);
+  warnings.push(...result.warnings);
+  const curriculumFeed = emitCurriculumFeed(result.hybridGraph, {
+    warnings
+  });
+  return {
+    hybridGraph: result.hybridGraph,
+    curriculumFeed,
+    warnings
+  };
+}
+
+// src/pipeline/domainRouter.ts
+async function runDomainPipeline(options) {
+  const warnings = [];
+  const log = (step, msg) => {
+    console.log(`[ROUTER-${step}] ${msg}`);
+    options.onProgress?.(step, msg);
+  };
+  log("LAYER_1", "Detecting domain profile...");
+  const domainProfile = detectDomainProfile(options);
+  const effectiveMode = options.forcedLearningMode || domainProfile.learningMode;
+  log("LAYER_2", `Routing to pipeline for learning mode: ${effectiveMode} (graphType: ${domainProfile.graphType})`);
+  if (effectiveMode === "concept") {
+    log("LAYER_3", "Executing Knowledge Graph Pipeline (Concept-driven)...");
+    const knowledgeResult = await runKnowledgeGraphPipeline({
+      subject: options.subject || domainProfile.detectedSubject || options.goal || options.description || "General Subject",
+      description: options.description,
+      syllabusText: options.syllabusText,
+      parsedSyllabus: options.parsedSyllabus,
+      gradeBand: options.gradeBand,
+      domain: domainProfile.domainCategory,
+      techStack: options.techStack || domainProfile.detectedTechStack?.[0],
+      llmConfig: options.llmConfig,
+      onProgress: options.onProgress,
+      knowledgeTreePath: options.knowledgeTreePath,
+      proposalsPath: options.proposalsPath
+    });
+    warnings.push(...knowledgeResult.warnings);
+    return {
+      domainProfile,
+      graphType: "knowledge_graph",
+      curriculumFeed: knowledgeResult.curriculumFeed,
+      knowledgeResult,
+      warnings
+    };
+  }
+  if (effectiveMode === "hybrid") {
+    log("LAYER_3", "Executing Hybrid Graph Pipeline...");
+    if (options.repoDir) {
+      const projectResult2 = await runProjectGraphPipeline({
+        repoDir: options.repoDir,
+        goal: options.goal || "Build complete project",
+        techStack: options.techStack || "typescript",
+        llmConfig: options.llmConfig,
+        embeddings: options.embeddings,
+        onProgress: options.onProgress
+      });
+      const knowledgeResult = await runKnowledgeGraphPipeline({
+        subject: options.subject || domainProfile.detectedSubject || options.goal || "Subject Theory",
+        description: options.description,
+        syllabusText: options.syllabusText,
+        parsedSyllabus: options.parsedSyllabus,
+        domain: domainProfile.domainCategory,
+        techStack: options.techStack,
+        llmConfig: options.llmConfig,
+        onProgress: options.onProgress
+      });
+      const hybridResult = await runHybridGraphPipeline({
+        projectGraph: projectResult2.projectGraph,
+        knowledgeGraph: knowledgeResult.knowledgeGraph,
+        llmConfig: options.llmConfig,
+        onProgress: options.onProgress
+      });
+      warnings.push(...hybridResult.warnings);
+      return {
+        domainProfile,
+        graphType: "hybrid_graph",
+        curriculumFeed: hybridResult.curriculumFeed,
+        projectResult: projectResult2,
+        knowledgeResult,
+        hybridResult,
+        warnings
+      };
+    } else {
+      warnings.push("Hybrid learning mode requested but repoDir was not provided \u2014 falling back to concept-driven knowledge graph pipeline");
+      const knowledgeResult = await runKnowledgeGraphPipeline({
+        subject: options.subject || domainProfile.detectedSubject || options.goal || "Subject Theory",
+        description: options.description,
+        syllabusText: options.syllabusText,
+        parsedSyllabus: options.parsedSyllabus,
+        domain: domainProfile.domainCategory,
+        techStack: options.techStack,
+        llmConfig: options.llmConfig,
+        onProgress: options.onProgress
+      });
+      warnings.push(...knowledgeResult.warnings);
+      return {
+        domainProfile,
+        graphType: "knowledge_graph",
+        curriculumFeed: knowledgeResult.curriculumFeed,
+        knowledgeResult,
+        warnings
+      };
+    }
+  }
+  log("LAYER_3", "Executing Project Graph Pipeline (Product-driven)...");
+  if (!options.repoDir) {
+    throw new Error("repoDir is required for product-driven project graph pipeline");
+  }
+  const projectResult = await runProjectGraphPipeline({
+    repoDir: options.repoDir,
+    goal: options.goal || "Build complete project",
+    techStack: options.techStack || domainProfile.detectedTechStack?.[0] || "typescript",
+    llmConfig: options.llmConfig,
+    embeddings: options.embeddings,
+    onProgress: options.onProgress
+  });
+  const { emitCurriculumFeed: emitCurriculumFeed2 } = await Promise.resolve().then(() => (init_curriculumFeedEmitter(), curriculumFeedEmitter_exports));
+  const curriculumFeed = emitCurriculumFeed2(projectResult.projectGraph, {
+    warnings
+  });
+  return {
+    domainProfile,
+    graphType: "project_graph",
+    curriculumFeed,
+    projectResult,
+    warnings
+  };
+}
+
 exports.ArchEdgeSchema = ArchEdgeSchema;
 exports.ArchNodeSchema = ArchNodeSchema;
 exports.ArchitectureDetailSchema = ArchitectureDetailSchema;
@@ -5436,7 +6032,6 @@ exports.CapabilitySchema = CapabilitySchema;
 exports.ConceptCategorySchema = ConceptCategorySchema;
 exports.ConceptIntroductionSchema = ConceptIntroductionSchema;
 exports.ConceptSchema = ConceptSchema;
-exports.CurriculumFeedSchema = CurriculumFeedSchema;
 exports.DataIntegrationSchema = DataIntegrationSchema;
 exports.DecompositionSchema = DecompositionSchema;
 exports.DetectionConfidenceSchema = DetectionConfidenceSchema;
@@ -5446,13 +6041,9 @@ exports.DomainCategorySchema = DomainCategorySchema;
 exports.DomainProfileSchema = DomainProfileSchema;
 exports.ExperienceComponentSchema = ExperienceComponentSchema;
 exports.ExperienceSchema = ExperienceSchema;
+exports.ExperimentProcedureSchema = ExperimentProcedureSchema;
 exports.FeatureSchema = FeatureSchema;
-exports.FeedEdgeSchema = FeedEdgeSchema;
-exports.FeedGroupingSchema = FeedGroupingSchema;
-exports.FeedKeywordsSchema = FeedKeywordsSchema;
-exports.FeedNodeSchema = FeedNodeSchema;
-exports.FeedPhaseSchema = FeedPhaseSchema;
-exports.FeedScaffoldCandidateSchema = FeedScaffoldCandidateSchema;
+exports.GrammarRuleSchema = GrammarRuleSchema;
 exports.GraphTypeSchema = GraphTypeSchema;
 exports.HardwareFeatureExtensionSchema = HardwareFeatureExtensionSchema;
 exports.HardwareStepSchema = HardwareStepSchema;
@@ -5465,8 +6056,11 @@ exports.JourneySchema = JourneySchema;
 exports.JourneyStepSchema = JourneyStepSchema;
 exports.KnowledgeGraphSchema = KnowledgeGraphSchema;
 exports.LEARNER_CLAUSE = LEARNER_CLAUSE;
+exports.LanguageConceptExtensionSchema = LanguageConceptExtensionSchema;
 exports.LearningModeSchema = LearningModeSchema;
 exports.LearningPathStepSchema = LearningPathStepSchema;
+exports.MathConceptExtensionSchema = MathConceptExtensionSchema;
+exports.MathTheoremSchema = MathTheoremSchema;
 exports.MilestoneDecompositionSchema = MilestoneDecompositionSchema;
 exports.MissingGapSchema = MissingGapSchema;
 exports.NavigationSchema = NavigationSchema;
@@ -5479,6 +6073,7 @@ exports.ProjectGraphSchema = ProjectGraphSchema;
 exports.ProjectInfoSchema = ProjectInfoSchema;
 exports.RequirementSchema = RequirementSchema;
 exports.SIO_CODE_RE = SIO_CODE_RE;
+exports.ScienceConceptExtensionSchema = ScienceConceptExtensionSchema;
 exports.ScreenSchema = ScreenSchema;
 exports.ShapeSchema = ShapeSchema;
 exports.StepEffortSchema = StepEffortSchema;
@@ -5499,6 +6094,8 @@ exports.WiringSchema = WiringSchema;
 exports.assembleRoadmap = assembleRoadmap;
 exports.assignConceptCodes = assignConceptCodes;
 exports.auditDepthLayers = auditDepthLayers;
+exports.auditSyllabusCoverage = auditSyllabusCoverage;
+exports.breakPrerequisiteCycles = breakPrerequisiteCycles;
 exports.cioActionSlug = cioActionSlug;
 exports.cioCode = cioCode;
 exports.conceptCodeFromName = conceptCodeFromName;
@@ -5506,6 +6103,7 @@ exports.detectDomain = detectDomain;
 exports.detectDomainProfile = detectDomainProfile;
 exports.detectInputType = detectInputType;
 exports.detectLearningMode = detectLearningMode;
+exports.detectPrerequisiteCycles = detectPrerequisiteCycles;
 exports.emitCurriculumFeed = emitCurriculumFeed;
 exports.escalateAndMapConcepts = escalateAndMapConcepts;
 exports.extractFeatureSteps = extractFeatureSteps;
@@ -5522,8 +6120,12 @@ exports.mergeTsResults = mergeTsResults;
 exports.parseCppFile = parseCppFile;
 exports.parsePythonFile = parsePythonFile;
 exports.parseSwiftFile = parseSwiftFile;
+exports.parseSyllabus = parseSyllabus;
 exports.parseTsFile = parseTsFile;
 exports.resolveConcepts = resolveConcepts;
+exports.runDomainPipeline = runDomainPipeline;
+exports.runHybridGraphPipeline = runHybridGraphPipeline;
+exports.runKnowledgeGraphPipeline = runKnowledgeGraphPipeline;
 exports.runProjectGraphPipeline = runProjectGraphPipeline;
 exports.scoreByContent = scoreByContent;
 exports.scoreByPath = scoreByPath;
@@ -5534,6 +6136,7 @@ exports.standardStatement = standardStatement;
 exports.techTagFor = techTagFor;
 exports.uloCode = uloCode;
 exports.validateCurriculumFeed = validateCurriculumFeed;
+exports.verifyKnowledgeGraph = verifyKnowledgeGraph;
 exports.verifyProjectGraph = verifyProjectGraph;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map