@thanh01.pmt/domain-kit 0.1.0 → 0.2.0

package/dist/pipeline/index.cjs

@@ -1,8 +1,497 @@
 'use strict';
 
+var zod = require('zod');
 var fs = require('fs');
 var path = require('path');
 var child_process = require('child_process');
+var os = require('os');
+
+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 = 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;
+}
+var FeedKeywordsSchema, FeedScaffoldCandidateSchema, FeedNodeSchema, FeedEdgeSchema, FeedGroupingSchema, FeedPhaseSchema, CurriculumFeedSchema;
+var init_curriculumFeedSchema = __esm({
+  "src/schemas/curriculumFeedSchema.ts"() {
+    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([])
+    });
+    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")
+    });
+    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)
+    });
+    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("")
+    });
+    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("")
+    });
+    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)
+    });
+    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([])
+    });
+  }
+});
+
+// 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") : [];
+  }
+});
 
 // src/parsers/swift.ts
 var IMPORT_RE = /^import\s+(\w+)/gm;
@@ -1530,10 +2019,10 @@ function splitFeatureIntoMilestones(feature, featureConcepts, maxMinutes, overhe
   const steps = feature.steps || [];
   if (steps.length === 0) return [];
   const featureId = feature.id || "F_UNK";
-  const stepMinutes = steps.map((s) => s.effort?.estimated_minutes || 15);
-  const totalRawMinutes = stepMinutes.reduce((a, b) => a + b, 0);
+  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, stepMinutes, featureId, 1)];
+    return [buildMilestone(feature, featureConcepts, steps, stepMinutes2, featureId, 1)];
   }
   const milestones = [];
   let currentSteps = [];
@@ -1541,7 +2030,7 @@ function splitFeatureIntoMilestones(feature, featureConcepts, maxMinutes, overhe
   let milestoneIndex = 1;
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
-    const mins = stepMinutes[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(
@@ -1571,8 +2060,8 @@ function splitFeatureIntoMilestones(feature, featureConcepts, maxMinutes, overhe
   }
   return milestones;
 }
-function buildMilestone(feature, featureConcepts, steps, stepMinutes, featureId, milestoneIndex) {
-  const rawMinutes = stepMinutes.reduce((a, b) => a + b, 0);
+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();
@@ -2161,6 +2650,2651 @@ async function runProjectGraphPipeline(options) {
   };
 }
 
+// src/graph/loCodeStandard.ts
+var TECH_TAG_MAP = {
+  python: "PY",
+  swift: "SW",
+  typescript: "TS",
+  javascript: "JV",
+  java: "JAVA",
+  kotlin: "KT",
+  go: "GO",
+  rust: "RUST",
+  csharp: "CS",
+  cpp: "CPP",
+  dart: "DT",
+  php: "PHP",
+  ruby: "RB",
+  sql: "SQL",
+  html: "HTML",
+  css: "CSS"
+};
+function techTagFor(techStack) {
+  const primary = (techStack).trim().toLowerCase();
+  for (const [key, tag] of Object.entries(TECH_TAG_MAP)) {
+    if (primary.includes(key)) return tag;
+  }
+  const first = primary.split(/[\s,+/]+/)[0] ?? "";
+  if (!/^[a-z]/.test(first)) return "GEN";
+  return first.length <= 4 ? first.toUpperCase() : first.slice(0, 3).toUpperCase();
+}
+var SMALL_WORDS = /* @__PURE__ */ new Set(["and", "or", "the", "of", "for", "in", "on", "a", "an", "vs"]);
+function conceptCodeFromName(name) {
+  const words = name.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter((w) => w.length > 0 && !SMALL_WORDS.has(w.toLowerCase()));
+  const base = words.join("_").toUpperCase().replace(/^_+|_+$/g, "").replace(/_{2,}/g, "_");
+  const trimmed = (base || "CONCEPT").slice(0, 60).replace(/_+$/g, "");
+  return trimmed;
+}
+function assignConceptCodes(concepts) {
+  const used = /* @__PURE__ */ new Map();
+  const out = {};
+  for (const c of concepts) {
+    const base = conceptCodeFromName(c.name);
+    const n = (used.get(base) ?? 0) + 1;
+    used.set(base, n);
+    out[c.id] = n === 1 ? base : base + "_" + n;
+  }
+  return out;
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+function uloCode(conceptCode, seq = 1) {
+  return "ULO-" + conceptCode + "-" + pad2(seq);
+}
+var CIO_STOPWORDS = /* @__PURE__ */ new Set([
+  // clause boilerplate
+  "learner",
+  "will",
+  "be",
+  "able",
+  // generic fillers
+  "a",
+  "an",
+  "the",
+  "of",
+  "to",
+  "and",
+  "or",
+  "in",
+  "on",
+  "for",
+  "by",
+  "with",
+  "is",
+  "are",
+  "that",
+  "it",
+  "its",
+  "their",
+  "when",
+  "how",
+  "as",
+  "into",
+  "from"
+]);
+function cioActionSlug(cioText) {
+  const body = cioText.startsWith(LEARNER_CLAUSE) ? cioText.slice(LEARNER_CLAUSE.length) : cioText;
+  const words = body.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).map((w) => w.toLowerCase()).filter((w) => w.length > 2 && !CIO_STOPWORDS.has(w));
+  const seen = /* @__PURE__ */ new Set();
+  const picked = [];
+  for (const w of words) {
+    if (!seen.has(w)) {
+      seen.add(w);
+      picked.push(w);
+    }
+    if (picked.length === 3) break;
+  }
+  return (picked.length > 0 ? picked : ["apply"]).join("_").toUpperCase();
+}
+function cioCode(conceptCode, uloSeq, actionSlug) {
+  return "CIO-" + conceptCode + "-" + pad2(uloSeq) + "-" + actionSlug;
+}
+function sioCode(techTag, conceptCode, seq) {
+  return "SIO-" + techTag + "-" + conceptCode + "-" + pad2(seq);
+}
+var LEARNER_CLAUSE = "The learner will be able to ";
+function standardStatement(text) {
+  let body = (text || "").trim().replace(/^the learner (will be able to|can)\s*/i, "").replace(/\s+/g, " ");
+  if (body.length === 0) return "";
+  const firstWord = body.split(" ")[0] ?? "";
+  const looksAcronym = /^[A-Z0-9_.`]+$/.test(firstWord) && firstWord.length > 1;
+  if (!looksAcronym) body = body.charAt(0).toLowerCase() + body.slice(1);
+  body = body.replace(/[.\s]+$/, "");
+  return LEARNER_CLAUSE + body + ".";
+}
+var CONCEPT_CODE_RE = /^[A-Z][A-Z0-9_]*$/;
+var ULO_CODE_RE = /^ULO-[A-Z][A-Z0-9_]*-\d{2}$/;
+var CIO_CODE_RE = /^CIO-[A-Z][A-Z0-9_]*-\d{2}-[A-Z][A-Z0-9_]*$/;
+var SIO_CODE_RE = /^SIO-[A-Z0-9]+-[A-Z][A-Z0-9_]*-\d{2}$/;
+
+// src/parsers/syllabusParser.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "and",
+  "the",
+  "for",
+  "with",
+  "from",
+  "that",
+  "this",
+  "into",
+  "when",
+  "while",
+  "using",
+  "their",
+  "your",
+  "each",
+  "how",
+  "why",
+  "what",
+  "between",
+  "through",
+  "about",
+  "trong",
+  "nhung",
+  "cac",
+  "cua",
+  "cho",
+  "voi",
+  "duoc",
+  "khong",
+  "theo",
+  "tren",
+  "duoi",
+  "va",
+  "hoac",
+  "thi",
+  "la",
+  "nhu"
+]);
+function extractTokens(text) {
+  const words = text.toLowerCase().replace(/[^a-z0-9à-ỹ\s-]/gi, " ").split(/\s+/).filter((w) => w.length >= 3 && !STOP_WORDS.has(w));
+  return [...new Set(words)];
+}
+function extractGradeBand(text) {
+  const gbMatch = text.match(/(?:grade\s*band|độ\s*tuổi|lớp)\s*[:=]?\s*(?:lớp\s*)?(\d{1,2})\s*(?:-|đến|to)\s*(?:lớp\s*)?(\d{1,2})/i);
+  if (gbMatch && gbMatch[1] && gbMatch[2]) {
+    const min = parseInt(gbMatch[1], 10);
+    const max = parseInt(gbMatch[2], 10);
+    return [Math.min(min, max), Math.max(min, max)];
+  }
+  return void 0;
+}
+function extractDomain(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("computer science") || lower.includes("l\u1EADp tr\xECnh") || lower.includes("algorithm") || lower.includes("software")) return "software";
+  if (lower.includes("to\xE1n") || lower.includes("geometry") || lower.includes("algebra") || lower.includes("h\xECnh h\u1ECDc") || lower.includes("mathematics")) return "math";
+  if (lower.includes("v\u1EADt l\xFD") || lower.includes("h\xF3a h\u1ECDc") || lower.includes("sinh h\u1ECDc") || lower.includes("physics") || lower.includes("chemistry") || lower.includes("biology") || lower.includes("science")) return "science";
+  if (lower.includes("ti\u1EBFng") || lower.includes("ng\u1EEF v\u0103n") || lower.includes("grammar") || lower.includes("language") || lower.includes("writing") || lower.includes("literature")) return "language";
+  return void 0;
+}
+function parseSyllabus(rawText) {
+  const lines = rawText.split(/\r?\n/);
+  let subjectTitle = "";
+  let subjectDesc = "";
+  const units = [];
+  const allTopics = [];
+  const globalKeywordsSet = /* @__PURE__ */ new Set();
+  let currentUnit = null;
+  let currentTopic = null;
+  let unitIndex = 0;
+  let topicIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    if (!line) continue;
+    if (line.startsWith("# ") && !subjectTitle) {
+      subjectTitle = line.replace(/^#\s+/, "").trim();
+      continue;
+    }
+    if (!currentUnit) {
+      if (line.toLowerCase().startsWith("m\xF4n h\u1ECDc:") || line.toLowerCase().startsWith("subject:")) {
+        const val = line.split(":")[1]?.trim() || "";
+        if (val && !subjectTitle) subjectTitle = val;
+      }
+      if (line.toLowerCase().startsWith("m\xF4 t\u1EA3:") || line.toLowerCase().startsWith("description:")) {
+        subjectDesc = line.split(":")[1]?.trim() || "";
+      }
+    }
+    const isUnitHeading = /^##\s+(?:chương|module|unit|phần|chủ đề)\s*(\d+|[ivx]+)?[:.-]?\s*(.*)/i.test(line) || /^##\s+([^#].*)/.test(line);
+    if (isUnitHeading) {
+      if (currentTopic) {
+        currentTopic.rawLineEnd = lineNum - 1;
+        currentTopic = null;
+      }
+      unitIndex += 1;
+      const titleMatch = line.replace(/^##\s+/, "").trim();
+      currentUnit = {
+        id: `U${String(unitIndex).padStart(2, "0")}`,
+        title: titleMatch,
+        order: unitIndex,
+        topics: []
+      };
+      units.push(currentUnit);
+      continue;
+    }
+    const isTopicItem = /^(?:-\s*\*\*(?:bài|topic|lesson|chủ đề)\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*?)\*\*)/i.exec(line) || /^###\s+(?:bài|topic|lesson)?\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*)/i.exec(line) || /^-\s+\*\*(.*?)\*\*/.exec(line) || /^(\d+)\.\s+(?:(?:\*\*)?(?:bài|topic|lesson)?\s*(\d+(?:\.\d+)?|\w+)?[:.-]?\s*(.*?)(?:\*\*)?)$/i.exec(line);
+    if (isTopicItem) {
+      if (currentTopic) {
+        currentTopic.rawLineEnd = lineNum - 1;
+      }
+      if (!currentUnit) {
+        unitIndex += 1;
+        currentUnit = {
+          id: `U${String(unitIndex).padStart(2, "0")}`,
+          title: subjectTitle || "General",
+          order: unitIndex,
+          topics: []
+        };
+        units.push(currentUnit);
+      }
+      topicIndex += 1;
+      const rawName = (isTopicItem[3] || isTopicItem[2] || isTopicItem[1] || `Topic ${topicIndex}`).trim();
+      currentTopic = {
+        id: `T${String(topicIndex).padStart(2, "0")}`,
+        title: rawName,
+        unitId: currentUnit.id,
+        unitTitle: currentUnit.title,
+        description: "",
+        learningObjectives: [],
+        keywords: [],
+        rawLineStart: lineNum,
+        rawLineEnd: lineNum
+      };
+      currentUnit.topics.push(currentTopic);
+      allTopics.push(currentTopic);
+      continue;
+    }
+    if (currentTopic) {
+      currentTopic.rawLineEnd = lineNum;
+      const stripped = line.replace(/^[-*•\s]+/, "").trim();
+      if (stripped.toLowerCase().startsWith("m\u1EE5c ti\xEAu:") || stripped.toLowerCase().startsWith("objectives:")) {
+        const content = stripped.replace(/^(?:mục tiêu|objectives):\s*/i, "").trim();
+        if (content) currentTopic.learningObjectives.push(content);
+        continue;
+      }
+      if (stripped.toLowerCase().startsWith("t\u1EEB kh\xF3a:") || stripped.toLowerCase().startsWith("keywords:")) {
+        const rawKw = stripped.replace(/^(?:từ khóa|keywords):\s*/i, "").trim();
+        const tokens2 = rawKw.split(/[,;]+/).map((k) => k.trim()).filter(Boolean);
+        for (const tok of tokens2) {
+          currentTopic.keywords.push(tok);
+          globalKeywordsSet.add(tok);
+        }
+        continue;
+      }
+      if (currentTopic.description) {
+        currentTopic.description += " " + stripped;
+      } else {
+        currentTopic.description = stripped;
+      }
+      for (const tok of extractTokens(stripped)) {
+        if (tok.length >= 4) globalKeywordsSet.add(tok);
+      }
+    }
+  }
+  if (currentTopic) {
+    currentTopic.rawLineEnd = lines.length;
+  }
+  if (!subjectTitle && units.length > 0) {
+    subjectTitle = units[0]?.title || "Untitled Subject";
+  }
+  return {
+    subject: {
+      title: subjectTitle || "Untitled Subject",
+      domain: extractDomain(rawText),
+      gradeBand: extractGradeBand(rawText),
+      description: subjectDesc
+    },
+    units,
+    allTopics,
+    extractedKeywords: [...globalKeywordsSet],
+    rawText
+  };
+}
+
+// src/graph/knowledgeGraphVerifier.ts
+function detectPrerequisiteCycles(concepts) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const path = [];
+  const prereqMap = /* @__PURE__ */ new Map();
+  for (const c of concepts) {
+    prereqMap.set(c.id, c.prerequisites || []);
+  }
+  function dfs(conceptId) {
+    if (inStack.has(conceptId)) {
+      const cycleStart = path.indexOf(conceptId);
+      if (cycleStart >= 0) {
+        cycles.push([...path.slice(cycleStart), conceptId]);
+      }
+      return;
+    }
+    if (visited.has(conceptId)) return;
+    visited.add(conceptId);
+    inStack.add(conceptId);
+    path.push(conceptId);
+    for (const prereq of prereqMap.get(conceptId) || []) {
+      dfs(prereq);
+    }
+    path.pop();
+    inStack.delete(conceptId);
+  }
+  for (const c of concepts) {
+    if (!visited.has(c.id)) {
+      dfs(c.id);
+    }
+  }
+  return cycles;
+}
+function breakPrerequisiteCycles(concepts, cycles) {
+  const removed = [];
+  const fixed = concepts.map((c) => ({ ...c, prerequisites: [...c.prerequisites || []] }));
+  for (const cycle of cycles) {
+    if (cycle.length >= 2) {
+      const breaker = cycle[cycle.length - 2];
+      const target = cycle[cycle.length - 1];
+      for (const concept of fixed) {
+        if (concept.id === breaker && target) {
+          concept.prerequisites = concept.prerequisites.filter((p) => p !== target);
+          removed.push({ from: breaker, to: target });
+        }
+      }
+    }
+  }
+  return { fixed, removed };
+}
+function auditSyllabusCoverage(concepts, syllabus) {
+  if (!syllabus || syllabus.allTopics.length === 0) {
+    return { coverageRatio: 1, totalTopics: 0, coveredTopics: 0, uncovered: [] };
+  }
+  const topics = syllabus.allTopics;
+  const coveredSet = /* @__PURE__ */ new Set();
+  for (const topic of topics) {
+    const topicKeywords = /* @__PURE__ */ new Set([
+      ...topic.title.toLowerCase().split(/\s+/),
+      ...(topic.keywords || []).map((k) => k.toLowerCase())
+    ]);
+    for (const concept of concepts) {
+      concept.name.toLowerCase();
+      (concept.description || "").toLowerCase();
+      (concept.keywords || []).map((k) => k.toLowerCase());
+      if (concept.id.toLowerCase() === topic.id.toLowerCase()) {
+        coveredSet.add(topic.id);
+        break;
+      }
+      const refs = concept.references || [];
+      const hasTopicRef = refs.some(
+        (r) => r.id === topic.id || r.title && r.title.toLowerCase() === topic.title.toLowerCase()
+      );
+      if (hasTopicRef) {
+        coveredSet.add(topic.id);
+        break;
+      }
+      const conceptKeywords = (concept.keywords || []).map((k) => k.toLowerCase());
+      const hasOverlap = conceptKeywords.some((k) => topicKeywords.has(k)) || concept.name.toLowerCase().includes(topic.title.toLowerCase()) || topic.title.toLowerCase().includes(concept.name.toLowerCase());
+      if (hasOverlap) {
+        coveredSet.add(topic.id);
+        break;
+      }
+    }
+  }
+  const totalTopics = topics.length;
+  const coveredTopics = coveredSet.size;
+  const coverageRatio = totalTopics > 0 ? coveredTopics / totalTopics : 1;
+  const uncovered = topics.filter((t) => !coveredSet.has(t.id)).map((t) => `${t.id}: ${t.title}`);
+  return { coverageRatio, totalTopics, coveredTopics, uncovered };
+}
+function verifyKnowledgeGraph(kg, syllabusOrOptions) {
+  const syllabus = syllabusOrOptions && "parsedSyllabus" in syllabusOrOptions ? syllabusOrOptions.parsedSyllabus : syllabusOrOptions;
+  const warnings = [];
+  let concepts = [...kg.concepts || []];
+  const conceptIds = new Set(concepts.map((c) => c.id));
+  for (const c of concepts) {
+    if ((c.prerequisites || []).includes(c.id)) {
+      c.prerequisites = (c.prerequisites || []).filter((p) => p !== c.id);
+      warnings.push(`Self-loop removed on concept ${c.id}`);
+    }
+  }
+  const danglingPrerequisites = [];
+  for (const c of concepts) {
+    const validPrereqs = [];
+    for (const p of c.prerequisites || []) {
+      if (!conceptIds.has(p)) {
+        danglingPrerequisites.push({ conceptId: c.id, missingPrereqId: p });
+        warnings.push(`Dangling prerequisite removed: ${c.id} -> ${p}`);
+      } else {
+        validPrereqs.push(p);
+      }
+    }
+    c.prerequisites = validPrereqs;
+  }
+  const initialCycles = detectPrerequisiteCycles(concepts);
+  let removedEdges = [];
+  if (initialCycles.length > 0) {
+    const broken = breakPrerequisiteCycles(concepts, initialCycles);
+    concepts = broken.fixed;
+    removedEdges = broken.removed;
+    for (const r of removedEdges) {
+      warnings.push(`Cycle broken: removed edge ${r.from} -> ${r.to}`);
+    }
+  }
+  const coverage = auditSyllabusCoverage(concepts, syllabus);
+  if (coverage.coverageRatio < 1) {
+    warnings.push(`Syllabus coverage ${(coverage.coverageRatio * 100).toFixed(1)}% (${coverage.coveredTopics}/${coverage.totalTopics} topics). Uncovered: ${coverage.uncovered.join(", ")}`);
+  }
+  for (const c of concepts) {
+    if (!c.ulo) warnings.push(`Concept ${c.id} missing ULO (WHAT + WHY)`);
+    if (!c.cio) warnings.push(`Concept ${c.id} missing CIO (HOW mechanism)`);
+    if (!c.sio || c.sio.length === 0) warnings.push(`Concept ${c.id} missing SIO implementation items`);
+  }
+  const valid = initialCycles.length === 0 && danglingPrerequisites.length === 0 && coverage.coverageRatio >= 0.8;
+  const verifiedGraph = {
+    ...kg,
+    concepts
+  };
+  const report = {
+    valid,
+    cycles: initialCycles,
+    removedEdges,
+    danglingPrerequisites,
+    coverageRatio: coverage.coverageRatio,
+    totalSyllabusTopics: coverage.totalTopics,
+    coveredSyllabusTopics: coverage.coveredTopics,
+    uncoveredTopics: coverage.uncovered,
+    warnings
+  };
+  return { verifiedGraph, report };
+}
+
+// src/graph/loExemplars.ts
+var ULO_EXEMPLARS = [
+  // Calibrated against production learning_objectives (UNIVERSAL rows, neutral)
+  "The learner will be able to recall the key concepts, terminology, and characteristics of layers of abstraction.",
+  "The learner will be able to explain how layers of abstraction hide implementation details while exposing essential behavior.",
+  "The learner will be able to explain how a program changes state through statements and control flow.",
+  "The learner will be able to differentiate local from global scope and describe how return values affect data flow.",
+  "The learner will be able to describe the mechanism of a loop, including its condition, step and stopping rule.",
+  "The learner will be able to explain why a representation format must balance readability against processing efficiency."
+];
+var CIO_EXEMPLARS = [
+  // Production CONCEPTUAL_IMPL rows: mechanism behind the clause, Marr 2-Language neutral
+  "The learner will be able to develop a conceptual model that explains the internal mechanism by which the representation produces its effect.",
+  "The learner will be able to compare alternative approaches for the same operation and describe the trade-offs between them.",
+  "The learner will be able to decompose the choice of representation into decisive criteria such as cost, fidelity and tolerance to change.",
+  "The learner will be able to describe the sequence of steps by which a process transforms its input into its output, including the stopping condition."
+];
+var SIO_EXEMPLARS = [
+  // Production SPECIFIC_IMPL style: keyword-bound completable tasks, tech-tagged tier
+  "The learner will be able to use argparse.ArgumentParser with add_subparsers to register add, done and list commands in a Python CLI.",
+  "The learner will be able to define a @dataclass with type hints and a __post_init__ method that raises ValueError on invariant violation.",
+  "The learner will be able to execute parameterized statements via sqlite3.Connection.execute inside a with conn: transaction to perform CRUD on a tasks table.",
+  "The learner will be able to write a pytest test that runs the CLI entry point via subprocess.run and asserts the exit code and printed output."
+];
+
+// src/graph/depthAudit.ts
+var TECH_SIGNAL_RES = [
+  /`[^`]+`/,
+  /\b[a-zA-Z_][A-Za-z0-9_]*\(\)/,
+  // call-with-arguments: Status(enum.Enum), field(default_factory=list)
+  /\b[A-Za-z_][A-Za-z0-9_]*\([^)]+\)/,
+  // attribute access glued to a value: enum.Enum, os.path, tasks.json
+  /[A-Za-z0-9_)\]]\.[A-Za-z_][A-Za-z0-9_]+/,
+  /[a-z]+_[a-z]+/,
+  /[a-z]+[A-Z][A-Za-z]*/,
+  /\.[a-z]{2,4}\b/,
+  /\b(?:API|SDK|JSON|XML|YAML|HTTP|SQL|UUID|URL|DOM|CLI|TUI|CSV|UTF|CRUD|DSL)\b/,
+  // Exception/error class names: Exception, ValueError, CustomError
+  /\b[A-Z][a-zA-Z0-9_]*(?:Error|Exception|Warning|Fault)\b/,
+  // class declarations or references: class Status, static methods on types
+  /\bclass\s+[A-Za-z_][A-Za-z0-9_]*/,
+  // inheritance/derivation mentions: inheriting from Exception, subclass of Base
+  /\b(?:inherit(?:ing|s)?|subclass(?:ing)?|deriv(?:ing|ed|es)?)\s+(?:from|of)\s+[A-Z][A-Za-z0-9_]*/
+];
+var GENERIC_STOP = /* @__PURE__ */ new Set(["e", "g", "i"]);
+function techSignalHits(text) {
+  const hits = [];
+  for (const re of TECH_SIGNAL_RES) {
+    const found = text.match(new RegExp(re.source, "g")) ?? [];
+    for (const m of found) if (!GENERIC_STOP.has(m.toLowerCase())) hits.push(m);
+  }
+  return hits;
+}
+function auditDepthLayers(concepts) {
+  return concepts.map((c) => {
+    const ulo = (c.ulo ?? "").trim();
+    const cio = (c.cio ?? "").trim();
+    const sioItems = (c.sio ?? []).map((s) => (s ?? "").trim()).filter(Boolean);
+    const uloTechSignals = techSignalHits(ulo);
+    const uloHasTechSignals = uloTechSignals.length > 0;
+    const IMPL_VERBS = /\b(implement|refactor|debug|serialize)\b/i;
+    const uloHasImplementationVerbs = IMPL_VERBS.test(ulo);
+    const registryKeywords = (c.keywords ?? []).map((k) => String(k).toLowerCase()).filter((k) => k.length >= 3);
+    const nameTokens = String(c.name ?? "").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+    const boundToConcept = (s) => {
+      const lower = s.toLowerCase();
+      return registryKeywords.some((k) => lower.includes(k)) || nameTokens.some((w) => lower.includes(w));
+    };
+    const sioUnboundItems = sioItems.filter((s) => {
+      if (techSignalHits(s).length > 0) return false;
+      return !boundToConcept(s);
+    });
+    const conceptKeywords = (c.keywords ?? []).map((k) => k.toLowerCase()).filter(Boolean);
+    const sioOffConceptItems = conceptKeywords.length > 0 ? sioItems.filter((s) => !boundToConcept(s)) : [];
+    const COMPLETABLE = /\b(build|create|implement|write|configure|add|use|apply|display|store|load|save|handle|parse|validate|test|register|compute|generate|print|format|convert|extend|define|execute|run|read|fetch|wrap|log|call|raise|install|import|export|declare|embed|model|represent|override|customize|enforce|mock|assert|query|index|cache|stream|split|join|strip|encode|decode|traverse|measure|evaluate|benchmark|diagnose|demonstrate|verify|organize|structure|choose|select|compare|distinguish|attach|annotate|expose|accept|manage|group|sort|filter|map|reduce|catch|throw|migrate|inspect|trace|parameterize|construct|design|capture)\b/i;
+    const sioNotCompletable = sioItems.filter((s) => !COMPLETABLE.test(s) && !/`[^`]+`/.test(s));
+    const density = (text) => {
+      if (!text) return 0;
+      return techSignalHits(text).length / Math.max(1, text.split(/\s+/).length) * 100;
+    };
+    const dUlo = density(ulo);
+    density(cio);
+    const dSio = sioItems.length > 0 ? Math.max(...sioItems.map(density)) : 0;
+    const concretenessIncreases = dSio > dUlo;
+    const clauseOk = ulo.startsWith(LEARNER_CLAUSE) && cio.startsWith(LEARNER_CLAUSE) && sioItems.every((t) => t.startsWith(LEARNER_CLAUSE));
+    const codeIssues = [];
+    const conceptCode = c.code;
+    if (conceptCode !== void 0 && !CONCEPT_CODE_RE.test(conceptCode)) codeIssues.push("concept code not UPPER_SNAKE: " + conceptCode);
+    const uloCodeVal = c.ulo_code;
+    if (uloCodeVal !== void 0 && uloCodeVal !== "" && !ULO_CODE_RE.test(uloCodeVal)) codeIssues.push("ULO code malformed: " + uloCodeVal);
+    const cioCodeVal = c.cio_code;
+    if (cioCodeVal !== void 0 && cioCodeVal !== "" && !CIO_CODE_RE.test(cioCodeVal)) codeIssues.push("CIO code malformed: " + cioCodeVal);
+    const sioCodeVals = c.sio_codes;
+    if (sioCodeVals !== void 0) {
+      if (sioCodeVals.length !== sioItems.length) codeIssues.push("SIO codes count mismatch");
+      for (const sc of sioCodeVals) if (!SIO_CODE_RE.test(sc)) codeIssues.push("SIO code malformed: " + sc);
+    }
+    const codesOk = codeIssues.length === 0;
+    const passed = !uloHasTechSignals && !uloHasImplementationVerbs && sioUnboundItems.length === 0 && sioOffConceptItems.length === 0 && sioNotCompletable.length === 0 && concretenessIncreases && clauseOk && codesOk;
+    return {
+      conceptId: c.id,
+      uloHasTechSignals,
+      uloTechSignals,
+      uloHasImplementationVerbs,
+      sioAllKeywordBound: sioUnboundItems.length === 0,
+      sioUnboundItems,
+      sioConceptKeywordBound: sioOffConceptItems.length === 0,
+      sioOffConceptItems,
+      sioAllCompletable: sioNotCompletable.length === 0,
+      sioNotCompletable,
+      concretenessIncreases,
+      clauseOk,
+      codesOk,
+      codeIssues,
+      passed
+    };
+  });
+}
+
+// src/graph/hierarchicalLoAuthoring.ts
+function excerpt(text, max) {
+  const t = (text || "").trim();
+  return t.length > max ? t.slice(0, max) + "..." : t;
+}
+async function chatJson(client, system, user) {
+  const r = await client.chat(
+    [{ role: "system", content: system }, { role: "user", content: user }],
+    { temperature: 0.1, maxTokens: parseInt(process.env.KG_MAX_TOKENS || "65536", 10) }
+  );
+  return parseJsonFromLlm(r.content);
+}
+var LO_BATCH_SIZE = 6;
+function chunkConcepts(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+var JSON_ONLY = "Return EXACTLY JSON. No markdown, no explanations.";
+async function authorDepthLayersHierarchically(client, concepts, techStack, warnings) {
+  const uloByConcept = {};
+  const cioByConcept = {};
+  const sioByConcept = {};
+  concepts.map((c) => "- " + c.id + ": " + c.name + (c.description ? " \u2014 " + excerpt(c.description, 160) : "")).join("\n");
+  const uloSystem = [
+    "You are a Curriculum Design Expert writing Universal Learning Objectives (ULO).",
+    "",
+    "ULO = Computational Tier: the CORE COMPETENCY \u2014 WHAT the concept is and WHY it exists \u2014",
+    "completely independent of any technology, language, framework, library, file format or tool.",
+    "",
+    "Rules:",
+    "1. NEVER mention a concrete technology, API, library, file name or syntax in a ULO.",
+    "2. Bind the ULO to the concept intrinsic nature: the problem it solves in principle.",
+    "3. Typical assessment level: Remember or Understand. Use pragmatic, measurable verbs",
+    "   (Explain, Differentiate, Identify, Describe) instead of Know/Understand/Summarize.",
+    "4. Cognitive Ceiling: do NOT force Analyze/Evaluate/Create ULOs \u2014 if the concept is",
+    "   foundational, its core competency is low-level. Higher levels are exercised later",
+    "   INDIRECTLY through implementation work, not in the ULO itself.",
+    "5. One ULO per concept; 1-2 sentences covering WHAT + WHY.",
+    "6. Statement form (mandatory): every ULO MUST read 'The learner will be able to ...' \u2014",
+    "   a lowercase actionable verb follows the clause (explain ..., differentiate ...).",
+    "   Do not prefix any other phrasing.",
+    "",
+    "Approved style exemplars (production bank):",
+    ULO_EXEMPLARS.map((e) => "- " + e).join("\n"),
+    "",
+    JSON_ONLY
+  ].join("\n");
+  for (const batch of chunkConcepts(concepts, LO_BATCH_SIZE)) {
+    const batchList = batch.map((c) => "- " + c.id + " (" + c.name + ")" + (c.description ? ": " + excerpt(c.description, 160) : "")).join("\n");
+    const batchUser = "Concepts:\n" + batchList + '\n\nReturn JSON:\n{"ulos":[{"concept_id":"C1","ulo":"..."}]}';
+    const uloRes = await chatJson(client, uloSystem, batchUser);
+    for (const u of uloRes.ulos ?? []) {
+      if (u.concept_id && u.ulo) uloByConcept[u.concept_id] = standardStatement(u.ulo);
+    }
+  }
+  for (const c of concepts) {
+    if (!uloByConcept[c.id]) {
+      warnings.push("Phase A: no ULO generated for " + c.id + " \u2014 kept empty (audit will fail)");
+      uloByConcept[c.id] = "";
+    }
+  }
+  concepts.map((c) => "- " + c.id + " (" + c.name + "): " + uloByConcept[c.id]).join("\n");
+  const cioSystem = [
+    "You are a Curriculum Design Expert writing Concept-level Instructional Objectives (CIO).",
+    "",
+    "CIO = Algorithmic Tier: the MECHANISM \u2014 HOW the concept works, step by step, at a",
+    "procedural level. CIOs are derived from approved ULOs.",
+    "",
+    "Rules:",
+    "1. Still technology-agnostic: describe the neutral pattern/approach WITHOUT concrete",
+    "   API names, libraries, file formats or syntax.",
+    "2. Marr 2-Language Test: the CIO must read as true and implementable regardless of",
+    "   whether the learner uses Python, Swift, JavaScript or any other language. If it",
+    "   only makes sense in one language, rewrite it more neutrally.",
+    "3. More concrete than the ULO: reference stages, conditions, ordering or trade-offs",
+    "   of the underlying process.",
+    "4. One CIO per concept; 1-3 sentences describing the mechanism.",
+    "5. Statement form (mandatory): every CIO MUST read 'The learner will be able to ...' \u2014",
+    "   the mechanism is described after the clause.",
+    "",
+    "Approved style exemplars (production bank):",
+    CIO_EXEMPLARS.map((e) => "- " + e).join("\n"),
+    "",
+    JSON_ONLY
+  ].join("\n");
+  for (const batch of chunkConcepts(concepts, LO_BATCH_SIZE)) {
+    new Set(batch.map((c) => c.id));
+    const batchUloContext = batch.map((c) => "- " + c.id + " (" + c.name + "): " + (uloByConcept[c.id] || "(missing)")).join("\n");
+    const batchCioUser = "Approved ULOs:\n" + batchUloContext + '\n\nReturn JSON:\n{"cios":[{"concept_id":"C1","cio":"..."}]}';
+    const cioRes = await chatJson(client, cioSystem, batchCioUser);
+    for (const x of cioRes.cios ?? []) {
+      if (x.concept_id && x.cio) cioByConcept[x.concept_id] = standardStatement(x.cio);
+    }
+  }
+  for (const c of concepts) {
+    if (!cioByConcept[c.id]) {
+      warnings.push("Phase B: no CIO generated for " + c.id + " \u2014 kept empty (audit will fail)");
+      cioByConcept[c.id] = "";
+    }
+  }
+  concepts.map((c) => "- " + c.id + " (" + c.name + "): CIO=" + cioByConcept[c.id] + " | ULO=" + uloByConcept[c.id]).join("\n");
+  const sioSystem = [
+    "You are a Curriculum Design Expert writing Specific Instructional Objectives (SIO).",
+    "",
+    "SIO = Implementation Tier: completable, context-specific implementation tasks derived",
+    "from approved CIOs, bound to the TARGET technology of the course.",
+    "",
+    "Rules:",
+    "1. EVERY SIO item MUST name concrete keywords/technologies: a real API, function,",
+    "   decorator, module, class, file or command of the target technology.",
+    "2. Each item is a completable task: an actionable verb + the concrete construct + the",
+    "   context where it is used. Application/Analysis/Creation skills are assessed",
+    "   INDIRECTLY through completing these tasks \u2014 there is no fixed Bloom ceiling.",
+    "   MACHINE CHECK: every item MUST contain at least one ACTION VERB from this whitelist",
+    "   (build, create, implement, write, configure, add, use, apply, display, store, load,",
+    "   save, handle, parse, validate, test, register, compute, generate, print, format,",
+    "   convert, extend, define, execute, run, read, fetch, wrap, log, call, raise, install,",
+    "   import, export, declare, embed, model, represent, override, customize, enforce, mock,",
+    "   assert, query, index, cache, stream, split, join, strip, encode, decode, traverse,",
+    "   measure, evaluate, benchmark, diagnose, demonstrate, verify, organize, structure,",
+    "   choose, select, compare, distinguish, attach, annotate, expose, accept, manage, group,",
+    "   sort, filter, map, reduce, catch, throw, migrate, inspect, trace, parameterize,",
+    "   construct, design, capture) \u2014 OR wrap the concrete construct in backticks.",
+    "   Items with abstract verbs (understand, learn, know, grasp, appreciate, explore) and",
+    "   no backtick construct FAIL the audit. Prefer starting the task phrase with the verb.",
+    "3. 2-3 items per concept, each referencing a DIFFERENT concrete construct.",
+    "4. Statement form (mandatory): every SIO MUST read 'The learner will be able to ...' \u2014",
+    "   the concrete task follows the clause.",
+    "",
+    "Approved style exemplars (production bank):",
+    SIO_EXEMPLARS.map((e) => "- " + e).join("\n"),
+    "",
+    JSON_ONLY
+  ].join("\n");
+  concepts.map((c) => "- " + c.id + " (" + c.name + "): " + ((c.keywords ?? []).slice(0, 10).join(", ") || "(none listed \u2014 use concrete constructs of " + techStack + ")")).join("\n");
+  for (const batch of chunkConcepts(concepts, LO_BATCH_SIZE)) {
+    const batchKw = batch.map((c) => "- " + c.id + " (" + c.name + "): " + ((c.keywords ?? []).slice(0, 10).join(", ") || "(none listed \u2014 use concrete constructs of " + techStack + ")")).join("\n");
+    const batchCioCtx = batch.map((c) => "- " + c.id + " (" + c.name + "): CIO=" + (cioByConcept[c.id] || "(missing)") + " | ULO=" + (uloByConcept[c.id] || "(missing)")).join("\n");
+    const batchSioUser = [
+      "Target technology: " + techStack,
+      "",
+      "Concept keywords (each SIO item MUST contain at least one of its concept's keywords):",
+      batchKw,
+      "",
+      "Approved CIOs and ULOs:",
+      batchCioCtx,
+      "",
+      "Return JSON:",
+      '{"sios":[{"concept_id":"C1","sio":["...","..."]}]}'
+    ].join("\n");
+    const sioRes = await chatJson(client, sioSystem, batchSioUser);
+    for (const x of sioRes.sios ?? []) {
+      if (x.concept_id && Array.isArray(x.sio)) sioByConcept[x.concept_id] = x.sio.map((item) => standardStatement(String(item)));
+    }
+  }
+  for (const c of concepts) {
+    if (!sioByConcept[c.id] || sioByConcept[c.id].length === 0) {
+      warnings.push("Phase C: no SIO generated for " + c.id + " \u2014 kept empty (audit will fail)");
+      sioByConcept[c.id] = [];
+    }
+  }
+  concepts.map((c) => c.id);
+  const auditOnce = () => auditDepthLayers(concepts.map((c) => ({
+    id: c.id,
+    name: c.name,
+    keywords: c.keywords ?? [],
+    ulo: uloByConcept[c.id],
+    cio: cioByConcept[c.id],
+    sio: sioByConcept[c.id]
+  })));
+  let audits = auditOnce();
+  const repairRound = async (round) => {
+    const failingNow = audits.filter((a) => !a.passed);
+    if (failingNow.length === 0) return false;
+    if (round > 1) warnings.push("Depth audit repair round " + round + ": " + failingNow.length + " concept(s) still failing");
+    const failing = failingNow;
+    {
+      warnings.push("Depth audit: " + failing.length + "/" + concepts.length + " concepts failed first audit \u2014 targeted repair");
+      const repairTargets = failing.map((a) => {
+        const c = concepts.find((x) => x.id === a.conceptId);
+        const issues = [];
+        if (a.uloHasTechSignals) issues.push("ULO names concrete technology (remove: " + a.uloTechSignals.join(", ") + ")");
+        if (a.uloHasImplementationVerbs) issues.push("ULO reads as an implementation task (rewrite as WHAT+WHY competency)");
+        for (const item of a.sioUnboundItems) issues.push("SIO not keyword-bound: " + excerpt(item, 120));
+        for (const item of a.sioOffConceptItems) issues.push("SIO does not reference any of this concept's keywords (" + (c?.keywords ?? []).join(", ") + "): " + excerpt(item, 120));
+        for (const item of a.sioNotCompletable) issues.push("SIO not a completable task: " + excerpt(item, 120));
+        if (!a.concretenessIncreases) issues.push("SIO is not more concrete than the ULO \u2014 bind it to concrete constructs");
+        return {
+          concept_id: a.conceptId,
+          name: c?.name ?? a.conceptId,
+          keywords: c?.keywords ?? [],
+          current: { ulo: uloByConcept[a.conceptId], cio: cioByConcept[a.conceptId], sio: sioByConcept[a.conceptId] },
+          issues
+        };
+      });
+      const repairSystem = [
+        "You repair depth-layer learning objectives that failed a deterministic contract audit.",
+        "For each concept, rewrite ONLY the layers mentioned in issues, keeping the others as-is.",
+        "Contract:",
+        "- ULO: WHAT+WHY, concept-bound, technology-agnostic, Remember/Understand verbs.",
+        "- CIO: HOW mechanism, technology-agnostic, more concrete than ULO, Marr 2-Language neutral.",
+        "- SIO: keyword-bound completable implementation tasks naming real constructs of " + techStack + ".",
+        "- BINDING RULE: every SIO item must contain at least one of the concept's listed keywords VERBATIM (copy the exact keyword text into the sentence).",
+        "- COMPLETABILITY RULE: every SIO item must contain an actionable verb (build, create, implement, write, configure, parse, validate, handle, store, load, run, read, fetch, display, generate, format, convert, test, debug, trace, measure, design, structure, select, filter, sort, map, reduce, catch, throw, migrate, deploy, query, index, cache, stream, inspect) or wrap a concrete construct in backticks \u2014 abstract verbs (understand, learn, know, grasp, explore, appreciate) always fail.",
+        "",
+        JSON_ONLY
+      ].join("\n");
+      const repairUser = [
+        "Failing concepts:",
+        JSON.stringify(repairTargets, null, 2),
+        "",
+        "Return the FULL repaired set for these concepts in the same 3-layer JSON shape:",
+        '{"repairs":[{"concept_id":"C1","ulo":"...","cio":"...","sio":["..."]}]}'
+      ].join("\n");
+      try {
+        const repairRes = await chatJson(client, repairSystem, repairUser);
+        for (const r of repairRes.repairs ?? []) {
+          if (!r.concept_id) continue;
+          if (r.ulo) uloByConcept[r.concept_id] = standardStatement(r.ulo);
+          if (r.cio) cioByConcept[r.concept_id] = standardStatement(r.cio);
+          if (Array.isArray(r.sio) && r.sio.length > 0) sioByConcept[r.concept_id] = r.sio.map((t) => standardStatement(String(t)));
+        }
+        audits = auditOnce();
+      } catch (err) {
+        warnings.push("Depth repair round failed: " + (err instanceof Error ? err.message : String(err)));
+      }
+    }
+    return audits.every((a) => a.passed);
+  };
+  for (let round = 1; round <= 2; round++) {
+    const allPass = await repairRound(round);
+    if (allPass) break;
+  }
+  const stillFailing = audits.filter((a) => !a.passed);
+  if (stillFailing.length > 0) {
+    try {
+      const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync3 } = await import('fs');
+      const dumpDir = (await import('os')).tmpdir() + "/domain-kit-debug/";
+      mkdirSync3(dumpDir, { recursive: true });
+      writeFileSync3(dumpDir + "depth-audit-debug.json", JSON.stringify(
+        stillFailing.map((a) => ({ audit: a, ulo: uloByConcept[a.conceptId], cio: cioByConcept[a.conceptId], sio: sioByConcept[a.conceptId] })),
+        null,
+        2
+      ));
+    } catch {
+    }
+    const detail = stillFailing.map((a) => a.conceptId + "[" + (a.uloHasTechSignals ? "ulo-tech " : "") + (a.uloHasImplementationVerbs ? "ulo-impl " : "") + (a.sioUnboundItems.length ? "sio-unbound " : "") + (a.sioNotCompletable.length ? "sio-incomplete" : "") + "]").join(", ");
+    throw new Error(
+      "Depth-layer contract audit failed after repair for: " + detail + " \u2014 regenerate or fix the prompt contract (fail-closed, no silent fallback)"
+    );
+  }
+  return { uloByConcept, cioByConcept, sioByConcept, audits, warnings };
+}
+function cell(v) {
+  return (v || "").split(",").map((s) => s.trim()).filter(Boolean);
+}
+function loadKnowledgeTreeCatalog(tsvPath) {
+  const text = fs.readFileSync(tsvPath, "utf8");
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  if (lines.length === 0) throw new Error("Knowledge tree TSV is empty: " + tsvPath);
+  const header = lines[0].split("	").map((h) => h.trim());
+  const col = (name) => header.indexOf(name);
+  const iT = col("item_type");
+  const iC = col("code");
+  const iN = col("name");
+  const iD = col("description");
+  const iCat = col("category_codes");
+  const iTpc = col("topic_codes");
+  const iPre = col("prerequisite_concept_codes");
+  const iKw = col("keywords");
+  for (const [name, idx] of [["item_type", iT], ["code", iC], ["name", iN]]) {
+    if (idx < 0) throw new Error("Knowledge tree TSV missing column: " + name);
+  }
+  const categories = /* @__PURE__ */ new Map();
+  const topics = /* @__PURE__ */ new Map();
+  const concepts = [];
+  for (const line of lines.slice(1)) {
+    const c = line.split("	");
+    const type = (c[iT] || "").trim();
+    const code = (c[iC] || "").trim();
+    const name = (c[iN] || "").trim();
+    if (!code || !name) continue;
+    if (type === "CATEGORY") categories.set(code, name);
+    if (type === "TOPIC") topics.set(code, { name, categoryCodes: cell(c[iCat]) });
+    if (type !== "CONCEPT") continue;
+    const topicCodes = cell(c[iTpc]);
+    const categoryCodes = /* @__PURE__ */ new Set();
+    for (const t of topicCodes) for (const cc of topics.get(t)?.categoryCodes || []) categoryCodes.add(cc);
+    concepts.push({
+      code,
+      name,
+      description: (c[iD] || "").trim(),
+      keywords: cell(c[iKw]),
+      topicCodes,
+      categoryCodes: [...categoryCodes],
+      prerequisiteCodes: cell(c[iPre])
+    });
+  }
+  if (concepts.length === 0) throw new Error("Knowledge tree TSV has no CONCEPT rows: " + tsvPath);
+  return { path: tsvPath, concepts, categories, topics };
+}
+function tokens(s) {
+  return new Set(
+    s.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 4)
+  );
+}
+function filterBySelection(catalog, selectedCategories, selectedTopics, analysisConcepts, maxConcepts = 120) {
+  const tps = new Set(selectedTopics.map((c) => c.trim().toUpperCase()).filter(Boolean));
+  const cats = new Set(selectedCategories.map((c) => c.trim().toUpperCase()).filter(Boolean));
+  const probe = analysisConcepts.map((c) => tokens(c.name + " " + c.keywords.join(" ")));
+  const probeAll = /* @__PURE__ */ new Set();
+  for (const p of probe) for (const w of p) probeAll.add(w);
+  const inSelection = (tc) => tc.topicCodes.some((t) => tps.has(t)) || tc.categoryCodes.some((c) => cats.has(c));
+  const overlapScore = (tc) => {
+    const tcTok = tokens(tc.name + " " + tc.description.slice(0, 300) + " " + tc.keywords.join(" "));
+    let overlap = 0;
+    for (const w of tcTok) if (probeAll.has(w)) overlap++;
+    const kwDirect = tc.keywords.filter((k) => {
+      const kl = k.toLowerCase();
+      return [...probeAll].some((w) => w === kl || w.length >= 5 && kl.includes(w));
+    }).length;
+    return overlap * 2 + kwDirect * 3;
+  };
+  const kept = catalog.concepts.filter((tc) => inSelection(tc) || overlapScore(tc) >= 6);
+  return kept.map((tc) => ({ tc, s: overlapScore(tc) })).sort((a, b) => b.s - a.s).slice(0, maxConcepts).map((x) => x.tc);
+}
+function renderShortlist(shortlist) {
+  return shortlist.map((tc) => "- " + tc.code + " | " + tc.name + " | kw: " + tc.keywords.slice(0, 8).join(", ") + (tc.prerequisiteCodes.length ? " | prereqs: " + tc.prerequisiteCodes.join(",") : "")).join("\n");
+}
+function renderCategoryTopicIndex(catalog) {
+  const topicToConcepts = /* @__PURE__ */ new Map();
+  for (const tc of catalog.concepts) for (const t of tc.topicCodes) topicToConcepts.set(t, (topicToConcepts.get(t) || 0) + 1);
+  const byCat = /* @__PURE__ */ new Map();
+  for (const [code, info] of catalog.topics) {
+    for (const cat of info.categoryCodes) {
+      const arr2 = byCat.get(cat) || [];
+      arr2.push(code + " " + info.name + " (" + (topicToConcepts.get(code) || 0) + " concepts)");
+      byCat.set(cat, arr2);
+    }
+  }
+  const out = [];
+  for (const [code, name] of catalog.categories) {
+    out.push("CATEGORY " + code + " \u2014 " + name);
+    for (const t of byCat.get(code) || []) out.push("    TOPIC: " + t);
+  }
+  return out.join("\n");
+}
+var JSON_ONLY2 = "Return ONLY a JSON object, no markdown fences, no commentary.";
+function parseJsonBlock(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) throw new Error("LLM standardization response has no JSON object");
+  return JSON.parse(text.slice(start, end + 1));
+}
+async function standardizeConcepts(opts) {
+  const { client, catalog, techStack = "python", proposalsPath } = opts;
+  const log = opts.onProgress ?? (() => {
+  });
+  const warnings = [];
+  const hasTopics = catalog.topics.size > 0;
+  const selSystem = [
+    "You pre-select relevant areas of an institutional knowledge tree before a detailed concept alignment pass.",
+    hasTopics ? "Given the analysis concepts, pick the TOPICS that could contain matching concepts. Concepts are filed under topics, so topics are the filter dimension." : "Given the analysis concepts, pick the CATEGORIES that could contain matching concepts.",
+    "- Be generous: missing a relevant topic corrupts the alignment; an extra topic only costs attention.",
+    "- Only codes that appear in the index are valid.",
+    JSON_ONLY2
+  ].join("\n");
+  const selUser = [
+    "ANALYSIS CONCEPTS:",
+    opts.concepts.map((c) => "- " + c.name + ": " + c.description.slice(0, 160)).join("\n"),
+    "",
+    "KNOWLEDGE TREE INDEX:",
+    renderCategoryTopicIndex(catalog),
+    "",
+    hasTopics ? 'Return JSON: {"relevant_topics":["TOPIC_CODE"]}' : 'Return JSON: {"relevant_categories":["CATEGORY_CODE"]}'
+  ].join("\n");
+  const selRes = await client.chat(
+    [{ role: "system", content: selSystem }, { role: "user", content: selUser }],
+    { temperature: 0, maxTokens: 4096 }
+  );
+  const sel = parseJsonBlock(selRes.content);
+  const selTps = hasTopics ? (sel.relevant_topics || []).map(String).filter(Boolean) : [];
+  const selCats = hasTopics ? [] : (sel.relevant_categories || []).map(String).filter(Boolean);
+  log("STEP_2_5", "LLM relevance pre-selection (" + (hasTopics ? "topics" : "categories") + "): " + (hasTopics ? selTps.join(",") : selCats.join(",")));
+  const shortlist = filterBySelection(catalog, selCats, selTps, opts.concepts);
+  log("STEP_2_5", "Filtered tree concepts: " + shortlist.length + "/" + catalog.concepts.length + " shortlisted for alignment");
+  if (shortlist.length === 0) throw new Error("Topic/category pre-selection eliminated every tree concept \u2014 fail-closed");
+  const system = [
+    "You align auto-derived learning concepts with an institutional knowledge tree.",
+    "For EACH input concept decide exactly one of:",
+    `  1. "standardized" - the concept teaches the SAME underlying knowledge as one tree concept. Applying a tree concept inside a specific product context (e.g. "File-based persistence in a CLI app") is STILL the tree concept if the core knowledge matches. Set tree_code to that concept's code.`,
+    "     Adopt the tree's terminology. Only propose new when the tree genuinely has NO concept teaching that knowledge (broader AND narrower both fail).",
+    '  2. "proposed_new" - no tree concept covers it at the same granularity. Propose an UPPER_SNAKE_CASE code (descriptive, stable, max 5 words) and a one-sentence definition.',
+    "     If between 1 and 3 tree concepts are CLOSE but not exact, list their codes in possible_tree_matches for human review.",
+    `For a "standardized" decision ALSO return "adopted_keywords": the subset of that tree concept's keywords (from the shortlist) that make sense for the course TECH STACK. Drop keywords that name tooling from other ecosystems (e.g. JS test runners for a Python course) \u2014 keep conceptual keywords even when spelled generically. Maximum 8, ordered most-relevant first.`,
+    "Rules:",
+    "- Judge by MEANING (definition + keywords), not by string similarity.",
+    '- COVERAGE RULE: a "standardized" match must cover ALL primary dimensions of the input concept \u2014 every distinct aspect named in its title or description. A tree concept covering only ONE of several aspects (e.g. "interpreting error messages" for a concept about error handling AND user experience) is a PARTIAL match: decide "proposed_new" and list that tree code in possible_tree_matches.',
+    "- Context-specific wording does NOT make a new concept: new concept = knowledge absent from the tree, not knowledge applied elsewhere.",
+    "- Every input concept MUST receive exactly one decision. Never merge two input concepts into one tree code.",
+    "- Prefer proposed_new over a wrong standardized match: a false match corrupts the curriculum.",
+    JSON_ONLY2
+  ].join("\n");
+  const user = [
+    "TECH STACK: " + techStack,
+    "",
+    "ANALYSIS CONCEPTS (to standardize):",
+    JSON.stringify(opts.concepts.map((c) => ({ id: c.id, name: c.name, description: c.description.slice(0, 300), keywords: c.keywords.slice(0, 12) })), null, 1),
+    "",
+    "KNOWLEDGE TREE SHORTLIST (pre-filtered, " + shortlist.length + " candidate concepts):",
+    renderShortlist(shortlist),
+    "",
+    'Return JSON: {"decisions":[{"id":"<input id>","decision":"standardized","tree_code":"TREE_CODE","adopted_keywords":["kw1","kw2"],"note":"one sentence"},',
+    '  {"id":"<input id>","decision":"proposed_new","proposed_code":"PROPOSED_CODE","proposed_definition":"...","possible_tree_matches":["CODE"]}]}'
+  ].join("\n");
+  const res = await client.chat(
+    [{ role: "system", content: system }, { role: "user", content: user }],
+    { temperature: 0, maxTokens: 8192 }
+  );
+  log("STEP_2_5", "Standardization response received (provider " + res.provider + ")");
+  const parsed = parseJsonBlock(res.content);
+  const decisions = parsed.decisions ?? [];
+  const byId = new Map(decisions.map((d) => [String(d.id), d]));
+  const finalDecisions = [];
+  const proposals = [];
+  for (const c of opts.concepts) {
+    const d = byId.get(c.id);
+    if (!d || d.decision !== "standardized" && d.decision !== "proposed_new") {
+      throw new Error("Concept " + c.id + " (" + c.name + ") has no standardization decision \u2014 fail-closed");
+    }
+    if (d.decision === "standardized") {
+      const tc = catalog.concepts.find((x) => x.code === d.tree_code);
+      if (!tc) throw new Error("Concept " + c.id + " standardized to unknown tree code " + d.tree_code + " \u2014 fail-closed");
+      const treeKw = new Set(tc.keywords.map((k) => k.toLowerCase()));
+      const adopted = (d.adopted_keywords || []).map((k) => String(k)).filter((k) => {
+        if (treeKw.has(k.toLowerCase())) return true;
+        throw new Error("Concept " + c.id + ' adopted keyword "' + k + '" not in tree concept ' + tc.code + " \u2014 fail-closed");
+      });
+      if (tc.keywords.length > 0 && adopted.length === 0) {
+        throw new Error("Concept " + c.id + " standardized to " + tc.code + " without adopted_keywords \u2014 fail-closed");
+      }
+      finalDecisions.push({ ...d, id: c.id, tree_code: tc.code, adopted_keywords: adopted });
+      warnings.push("Concept " + c.id + " standardized as " + tc.code + " (" + tc.name + "), adopted keywords: " + adopted.join(", ") + (d.note ? " \u2014 " + d.note : ""));
+    } else {
+      const code = (d.proposed_code || "").toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+      if (!/^[A-Z][A-Z0-9_]*$/.test(code)) {
+        throw new Error("Concept " + c.id + ' proposed invalid code "' + d.proposed_code + '" \u2014 fail-closed');
+      }
+      finalDecisions.push({ ...d, id: c.id, proposed_code: code });
+      proposals.push({
+        code,
+        name: c.name,
+        description: d.proposed_definition || c.description.slice(0, 300),
+        keywords: c.keywords,
+        subject_codes: "PY",
+        category_codes: "",
+        topic_codes: "",
+        prerequisite_concept_codes: [],
+        status: "proposed",
+        source_concept_id: c.id,
+        possible_tree_matches: (d.possible_tree_matches || []).filter(Boolean)
+      });
+      warnings.push("Concept " + c.id + " proposed as NEW: " + code + (d.possible_tree_matches?.length ? " (near matches: " + d.possible_tree_matches.join(", ") + ")" : ""));
+    }
+  }
+  const outPath = proposalsPath || path.join(os.tmpdir(), "domain-kit-debug", "concept-proposals.json");
+  try {
+    fs.mkdirSync(outPath.slice(0, outPath.lastIndexOf("/")), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify({ generated_at: (/* @__PURE__ */ new Date()).toISOString(), proposals }, null, 2));
+    log("STEP_2_5", "Proposals written: " + proposals.length + " -> " + outPath);
+  } catch (e) {
+    warnings.push("Could not write proposals artifact: " + (e instanceof Error ? e.message : String(e)));
+  }
+  return { decisions: finalDecisions, proposals, warnings, shortlistSize: shortlist.length, catalogSize: catalog.concepts.length };
+}
+
+// src/graph/knowledgeGraphPipeline.ts
+function topologicalSort(concepts) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const concept of concepts) {
+    inDegree.set(concept.id, 0);
+    adjacency.set(concept.id, []);
+  }
+  for (const concept of concepts) {
+    for (const prereq of concept.prerequisites || []) {
+      adjacency.get(prereq)?.push(concept.id);
+      inDegree.set(concept.id, (inDegree.get(concept.id) || 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const neighbor of adjacency.get(current) || []) {
+      const newDegree = (inDegree.get(neighbor) || 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  if (sorted.length !== concepts.length) {
+    console.warn(`[WARN] Topological sort incomplete: ${sorted.length}/${concepts.length} concepts sorted`);
+  }
+  return sorted;
+}
+async function generateKnowledgeGraph(options) {
+  const { subject, description, syllabusText, gradeBand, domain, techStack, llmConfig, onProgress } = options;
+  const warnings = [];
+  const log = (step, msg) => {
+    console.log(`[KG-${step}] ${msg}`);
+    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 = "";
+  if (syllabusText) {
+    if (syllabusText.length > maxSyllabusChars) {
+      truncatedSyllabus = syllabusText.slice(0, maxSyllabusChars);
+      warnings.push(`Syllabus truncated from ${syllabusText.length} to ${maxSyllabusChars} chars \u2014 may miss some concepts`);
+    } else {
+      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}` : ""}
+${structuredTopicsGuide}${truncatedSyllabus ? `Syllabus:
+${truncatedSyllabus}` : ""}
+${gradeBand ? `Grade band: ${gradeBand[0]}-${gradeBand[1]}` : ""}
+${domain ? `Domain: ${domain}` : ""}
+
+Return JSON:
+{
+  "subject": {
+    "id": "${subject.toLowerCase().replace(/\s+/g, "-").slice(0, 30)}",
+    "name": "${subject}",
+    "description": "...",
+    "domain": "${domain || "other"}",
+    "grade_band": ${gradeBand ? `[${gradeBand[0]}, ${gradeBand[1]}]` : "[6, 12]"}
+  },
+  "concepts": [
+    {
+      "id": "C1",
+      "name": "Concept name",
+      "description": "Brief description",
+      "category": "category_id",
+      "ulo": "WHAT + WHY in technology-agnostic language: what the concept is and the problem it exists to solve. No library/API/tool names.",
+      "cio": "HOW the mechanism works, still technology-agnostic but more concrete than the ULO.",
+      "sio": ["Concrete task naming a REAL API/function/module/file from the target technology, completable end to end", "Another technology-bound task using a different concrete keyword"],
+      "prerequisites": [],
+      "estimated_minutes": 30,
+      "problem_types": [
+        {
+          "id": "PT-C1-01",
+          "name": "Problem type name",
+          "description": "What this problem type tests",
+          "bloom_level": "Remember",
+          "difficulty": "easy",
+          "estimated_minutes": 10
+        }
+      ],
+      "techniques": ["technique 1", "technique 2"],
+      "common_mistakes": ["mistake 1"]
+    }
+  ],
+  "categories": [
+    {
+      "id": "cat1",
+      "name": "Category name",
+      "description": "Category description",
+      "concept_ids": ["C1", "C2"],
+      "order": 1
+    }
+  ],
+  "learning_path": [
+    {"concept_id": "C1", "order": 1, "depends_on": []},
+    {"concept_id": "C2", "order": 2, "depends_on": ["C1"]}
+  ]
+}`;
+  const result = await llmChatJson(client, systemPrompt, userPrompt, {
+    temperature: 0.1,
+    maxTokens: parseInt(process.env.KG_MAX_TOKENS || "65536", 10)
+  });
+  log("STEP_2", "Validating and cleaning knowledge graph...");
+  const concepts = result.concepts || [];
+  const categories = result.categories || [];
+  {
+    const STOP = /* @__PURE__ */ new Set(["and", "the", "for", "with", "from", "that", "this", "into", "when", "while", "using", "their", "your", "each", "how", "why", "what", "between", "through", "about"]);
+    const tokensFrom = (text) => text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length >= 4 && !STOP.has(w));
+    for (const c of concepts) {
+      const existing = (c.keywords || []).map((k) => String(k).trim()).filter(Boolean);
+      if (existing.length === 0) {
+        const derived = [.../* @__PURE__ */ new Set([...tokensFrom(c.name), ...tokensFrom(c.description || "")])].slice(0, 5);
+        if (derived.length === 0) {
+          throw new Error("Concept " + c.id + " (" + c.name + ") has no keywords and none could be derived from name/description \u2014 fail-closed");
+        }
+        c.keywords = derived;
+        warnings.push("Concept " + c.id + ": empty keyword set - derived " + derived.join(", ") + " from name/description");
+      } else {
+        c.keywords = existing;
+      }
+    }
+  }
+  const rawPath = result.learning_path;
+  let learningPath = (rawPath || []).map((s) => ({
+    concept_id: String(s.concept_id || ""),
+    order: Number(s.order || 0),
+    depends_on: Array.isArray(s.depends_on) ? s.depends_on.map(String) : [],
+    milestone_name: String(s.milestone_name || "")
+  }));
+  const conceptIds = new Set(concepts.map((c) => c.id));
+  for (const concept of concepts) {
+    for (const prereq of concept.prerequisites || []) {
+      if (!conceptIds.has(prereq)) {
+        warnings.push(`Concept ${concept.id} references non-existent prerequisite ${prereq} \u2014 removed`);
+        concept.prerequisites = (concept.prerequisites || []).filter((p) => p !== prereq);
+      }
+    }
+  }
+  if (options.knowledgeTreePath) {
+    const catalog = loadKnowledgeTreeCatalog(options.knowledgeTreePath);
+    log("STEP_2_5", "Knowledge tree loaded: " + catalog.concepts.length + " concepts from " + catalog.path.split("/").pop());
+    const std = await standardizeConcepts({
+      client,
+      concepts: concepts.map((c) => ({
+        id: c.id,
+        name: c.name,
+        description: c.description || "",
+        keywords: c.keywords || []
+      })),
+      catalog,
+      techStack,
+      proposalsPath: options.proposalsPath,
+      onProgress: log
+    });
+    warnings.push(...std.warnings);
+    const codeByStd = new Map(std.decisions.map((d) => [d.id, d]));
+    for (const c of concepts) {
+      const d = codeByStd.get(c.id);
+      if (!d) throw new Error("Concept " + c.id + " missing standardization decision \u2014 fail-closed");
+      if (d.decision === "standardized") {
+        c.standardization = "standardized";
+        c.tree_code = d.tree_code;
+        c.code = d.tree_code;
+        const tc = catalog.concepts.find((x) => x.code === d.tree_code);
+        if (tc) {
+          for (const k of d.adopted_keywords || []) {
+            if (!(c.keywords || []).some((x) => x.toLowerCase() === k.toLowerCase())) {
+              c.keywords = [...c.keywords || [], k];
+            }
+          }
+          c.tree_prerequisites = tc.prerequisiteCodes;
+        }
+      } else {
+        c.standardization = "proposed_new";
+        c.code = d.proposed_code;
+      }
+    }
+    const idByTreeCode = new Map(concepts.filter((c) => c.tree_code).map((c) => [c.tree_code, c.id]));
+    for (const c of concepts) {
+      for (const tp of c.tree_prerequisites || []) {
+        const target = idByTreeCode.get(tp);
+        if (target && target !== c.id && !(c.prerequisites || []).includes(target)) {
+          c.prerequisites = [...c.prerequisites || [], target];
+          warnings.push("Prereq seeded from tree: " + c.id + " <- " + tp + " (" + target + ")");
+        }
+      }
+    }
+    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 = 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 } = breakPrerequisiteCycles(concepts, cycles);
+    for (let i = 0; i < concepts.length; i++) {
+      const fixedConcept = fixed.find((f) => f.id === concepts[i].id);
+      if (fixedConcept) {
+        concepts[i] = { ...concepts[i], prerequisites: fixedConcept.prerequisites };
+      }
+    }
+    for (const { from, to } of removed) {
+      warnings.push(`Removed prerequisite edge: ${from} \u2192 ${to} (cycle breaker)`);
+    }
+  }
+  log("STEP_4", "Topological sort of concepts...");
+  const sortedIds = topologicalSort(concepts);
+  learningPath = sortedIds.map((id, idx) => {
+    const concept = concepts.find((c) => c.id === id);
+    return {
+      concept_id: id,
+      order: idx + 1,
+      depends_on: concept?.prerequisites || [],
+      milestone_name: ""
+    };
+  });
+  log("STEP_5", "Authoring ULO/CIO/SIO depth layers hierarchically...");
+  {
+    const lo = await authorDepthLayersHierarchically(
+      client,
+      concepts.map((c) => ({ id: c.id, name: c.name, description: c.description, keywords: c.keywords })),
+      techStack || (domain === "software" || domain === "technology" ? "python" : domain || "general"),
+      warnings
+    );
+    const codeByConceptId = assignConceptCodes(concepts.map((c) => ({ id: c.id, name: c.name })));
+    const techTag = techTagFor(techStack || (domain === "software" || domain === "technology" ? "python" : domain || "general"));
+    for (const concept of concepts) {
+      concept.ulo = lo.uloByConcept[concept.id] || concept.ulo || "";
+      concept.cio = lo.cioByConcept[concept.id] || concept.cio || "";
+      if (lo.sioByConcept[concept.id] && lo.sioByConcept[concept.id].length > 0) {
+        concept.sio = lo.sioByConcept[concept.id];
+      }
+      concept.code = concept.code || codeByConceptId[concept.id];
+      concept.ulo_code = concept.ulo ? uloCode(concept.code) : concept.ulo_code;
+      concept.cio_code = concept.cio ? cioCode(concept.code, 1, cioActionSlug(concept.cio)) : concept.cio_code;
+      concept.sio_codes = concept.sio.length > 0 ? concept.sio.map((_, i) => sioCode(techTag, concept.code, i + 1)) : concept.sio_codes;
+    }
+    log("STEP_5", "Depth layers authored: " + concepts.length + " concepts, audit " + lo.audits.filter((a) => a.passed).length + "/" + concepts.length + " passed");
+  }
+  for (const step of learningPath) {
+    if (!conceptIds.has(step.concept_id)) {
+      warnings.push(`Learning path references non-existent concept ${step.concept_id}`);
+    }
+  }
+  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: verifiedGraph,
+    warnings,
+    verificationReport: report
+  };
+}
+
+// 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/graph/hybridGraphPipeline.ts
+async function generateHybridGraph(options) {
+  const { projectGraph, knowledgeGraph, llmConfig, onProgress } = options;
+  const warnings = [];
+  const log = (step, msg) => {
+    console.log("[HG-" + step + "] " + msg);
+    onProgress?.(step, msg);
+  };
+  const features = projectGraph.features || [];
+  const concepts = knowledgeGraph.concepts || [];
+  if (features.length === 0 || concepts.length === 0) {
+    warnings.push("No features or concepts to link");
+    return {
+      hybridGraph: {
+        schema_version: 1,
+        type: "hybrid_graph",
+        project_graph: projectGraph,
+        knowledge_graph: knowledgeGraph,
+        links: [],
+        phases: [],
+        description: "",
+        total_project_minutes: 0,
+        total_concept_minutes: 0,
+        estimated_total_minutes: 0
+      },
+      warnings
+    };
+  }
+  const client = createLlmClient(llmConfig);
+  const featuresList = features.map(
+    (f) => "- " + f.id + ": " + f.name + " - " + (f.description || "") + " (keywords: " + (f.steps || []).flatMap((s) => s.keywords || []).slice(0, 5).join(", ") + ")"
+  ).join("\n");
+  const conceptsList = concepts.map(
+    (c) => "- " + c.id + ": " + c.name + " - ULO: " + (c.ulo || "").slice(0, 100) + " (prerequisites: " + (c.prerequisites || []).join(", ") + ")"
+  ).join("\n");
+  const systemPrompt = "You are a curriculum architect. Link project features to knowledge concepts.\nFor each feature, determine which concepts it requires or demonstrates.\n\nRULES:\n1. Each link must have a relationship type: requires | demonstrates | applies | extends\n2. depth indicates how deeply the feature needs the concept:\n   - ulo: feature only needs WHAT+WHY understanding\n   - cio: feature needs HOW understanding\n   - sio: feature needs specific implementation knowledge\n3. estimated_prereq_minutes: how many minutes of concept learning before this feature\n4. Not every feature needs every concept - only create meaningful links\n5. Return JSON object with a links array";
+  const userPrompt = "FEATURES:\n" + featuresList + "\n\nCONCEPTS:\n" + conceptsList + "\n\nCreate links between features and concepts. Return JSON.\n";
+  const result = await llmChatJson(client, systemPrompt, userPrompt, {
+    temperature: 0.1,
+    maxTokens: 16384
+  });
+  const rawLinks = result.links || [];
+  const featureIds = new Set(features.map((f) => f.id));
+  const conceptIds = new Set(concepts.map((c) => c.id));
+  const validLinks = [];
+  for (const link of rawLinks) {
+    const fid = String(link.feature_id || "");
+    const cid = String(link.concept_id || "");
+    if (!featureIds.has(fid)) {
+      warnings.push("Link references non-existent feature " + fid);
+      continue;
+    }
+    if (!conceptIds.has(cid)) {
+      warnings.push("Link references non-existent concept " + cid);
+      continue;
+    }
+    validLinks.push({
+      feature_id: fid,
+      concept_id: cid,
+      relationship: link.relationship || "requires",
+      depth: link.depth || "cio",
+      description: String(link.description || ""),
+      estimated_prereq_minutes: Number(link.estimated_prereq_minutes) || 0,
+      phase_id: ""
+    });
+  }
+  log("STEP_1", "Generated " + validLinks.length + " feature-concept links");
+  const phases = await decomposePhases({
+    features,
+    concepts,
+    links: validLinks,
+    client,
+    log,
+    warnings
+  });
+  const phaseByFeature = /* @__PURE__ */ new Map();
+  for (const ph of phases) {
+    for (const fid of ph.feature_ids) phaseByFeature.set(fid, ph.id);
+  }
+  for (const link of validLinks) link.phase_id = phaseByFeature.get(link.feature_id) || "";
+  log("STEP_3", "Calculating totals...");
+  const totalProjectMinutes = features.reduce((sum, f) => {
+    const featureMinutes = (f.steps || []).reduce((s, step) => s + (step.effort?.estimated_minutes || 15), 0);
+    return sum + featureMinutes;
+  }, 0);
+  const totalConceptMinutes = concepts.reduce((sum, c) => sum + (c.estimated_minutes || 30), 0);
+  const prereqMinutesByConcept = /* @__PURE__ */ new Map();
+  for (const link of validLinks) {
+    const mins = link.estimated_prereq_minutes || 0;
+    if (mins > 0) {
+      const existing = prereqMinutesByConcept.get(link.concept_id) || 0;
+      prereqMinutesByConcept.set(link.concept_id, Math.max(existing, mins));
+    }
+  }
+  const totalPrereqMinutes = Array.from(prereqMinutesByConcept.values()).reduce((a, b) => a + b, 0);
+  return {
+    hybridGraph: {
+      schema_version: 1,
+      type: "hybrid_graph",
+      project_graph: projectGraph,
+      knowledge_graph: knowledgeGraph,
+      links: validLinks,
+      phases,
+      description: "Progressive completion path: " + phases.length + " phases, " + features.length + " features, " + concepts.length + " concepts",
+      total_project_minutes: totalProjectMinutes,
+      total_concept_minutes: totalConceptMinutes,
+      estimated_total_minutes: totalProjectMinutes + totalPrereqMinutes
+    },
+    warnings
+  };
+}
+function auditPhasePlan(plan, features, concepts, links, warnings, log) {
+  const knownFeatureIds = new Set(features.map((f) => f.id));
+  const knownConceptIds = new Set(concepts.map((c) => c.id));
+  const prereqOf = /* @__PURE__ */ new Map();
+  for (const c of concepts) prereqOf.set(c.id, (c.prerequisites || []).filter((p) => knownConceptIds.has(p)));
+  const phases = [];
+  const featurePhase = /* @__PURE__ */ new Map();
+  const newIntroPhase = /* @__PURE__ */ new Map();
+  const errors = [];
+  plan.forEach((rp, idx) => {
+    const id = String(rp.id || "PH" + (idx + 1));
+    const order = idx + 1;
+    const name = String(rp.name || "Phase " + order).slice(0, 80);
+    const productCompletion = String(rp.product_completion || "").trim();
+    const rawFeatureIds = Array.isArray(rp.feature_ids) ? rp.feature_ids.map(String) : [];
+    const rawIntros = Array.isArray(rp.introduces) ? rp.introduces : [];
+    if (!productCompletion) {
+      errors.push("Phase " + id + ": product_completion is empty - every phase must describe the product completion level");
+    }
+    const featureIdsForPhase = [];
+    for (const fid of rawFeatureIds) {
+      if (!knownFeatureIds.has(fid)) {
+        errors.push("Phase " + id + ": unknown feature " + fid);
+        continue;
+      }
+      if (featurePhase.has(fid)) {
+        errors.push("Feature " + fid + " assigned to both " + featurePhase.get(fid) + " and " + id + " - each feature must belong to exactly one phase");
+        continue;
+      }
+      featurePhase.set(fid, id);
+      featureIdsForPhase.push(fid);
+    }
+    const introductions = [];
+    for (const ri of rawIntros) {
+      const cid = String(ri.concept_id || "");
+      if (!knownConceptIds.has(cid)) {
+        errors.push("Phase " + id + ": introduces unknown concept " + cid);
+        continue;
+      }
+      const aspect = String(ri.aspect || "new") === "advanced" ? "advanced" : "new";
+      if (aspect === "advanced") {
+        const first = newIntroPhase.get(cid);
+        if (first === void 0) {
+          errors.push("Phase " + id + ": advanced introduction of " + cid + " before any new introduction - revisit requires prior introduction");
+          continue;
+        }
+        if (first >= order) {
+          errors.push("Phase " + id + ": advanced introduction of " + cid + " must come after its new introduction in phase " + first);
+          continue;
+        }
+      } else if (newIntroPhase.has(cid)) {
+        errors.push("Phase " + id + ": duplicate new introduction of " + cid + " (already introduced in phase " + newIntroPhase.get(cid) + ")");
+        continue;
+      } else {
+        newIntroPhase.set(cid, order);
+      }
+      for (const pre of prereqOf.get(cid) || []) {
+        if (!newIntroPhase.has(pre)) {
+          errors.push("Phase " + id + ": concept " + cid + " introduced before its prerequisite " + pre + " is introduced - violates the prerequisite chain");
+        }
+      }
+      introductions.push({ concept_id: cid, aspect, note: String(ri.note || "") });
+    }
+    phases.push({
+      id,
+      order,
+      name,
+      product_completion: productCompletion,
+      feature_ids: featureIdsForPhase,
+      introduces: introductions
+    });
+  });
+  const missing = features.map((f) => f.id).filter((fid) => !featurePhase.has(fid));
+  if (missing.length > 0) {
+    errors.push("Features not assigned to any phase: " + missing.join(", "));
+  }
+  const firstConsumerPhase = /* @__PURE__ */ new Map();
+  const phaseOrderByFeature = /* @__PURE__ */ new Map();
+  for (const ph of phases) for (const fid of ph.feature_ids) phaseOrderByFeature.set(fid, ph.order);
+  for (const l of links) {
+    const po = phaseOrderByFeature.get(l.feature_id);
+    if (po === void 0) continue;
+    const cur = firstConsumerPhase.get(l.concept_id);
+    if (cur === void 0 || po < cur) firstConsumerPhase.set(l.concept_id, po);
+  }
+  for (const [cid, consumerOrder] of firstConsumerPhase) {
+    const intro = newIntroPhase.get(cid);
+    if (intro === void 0) {
+      errors.push("Concept " + cid + " is consumed from phase " + consumerOrder + " but never introduced in any phase");
+    } else if (intro > consumerOrder) {
+      errors.push("Concept " + cid + " introduced in phase " + intro + " but first consumed in phase " + consumerOrder + " - introduction must come no later than first consumption");
+    }
+  }
+  return { phases, errors };
+}
+async function decomposePhases(args) {
+  const { features, concepts, links, client, log, warnings } = args;
+  const featureList = features.map(
+    (f) => "- " + f.id + ": " + f.name + " - " + (f.description || "").slice(0, 120)
+  ).join("\n");
+  const conceptList = concepts.map(
+    (c) => "- " + c.id + ": " + c.name + " (prerequisites: " + ((c.prerequisites || []).join(", ") || "none") + ")"
+  ).join("\n");
+  const linkList = links.map(
+    (l) => "- " + l.feature_id + " -> " + l.concept_id + " (" + l.depth + ")"
+  ).join("\n") || "(none)";
+  const systemPrompt = "You decompose a software project build into PROGRESSIVE COMPLETION PHASES for learning purposes.\n\nA phase is NOT a feature and NOT a milestone list: it is a cross-feature slice of the\nproduct whose completion yields a DEMONSTRABLY more complete product. Build up gradually:\nthe product grows feature by feature across phases, and each phase adds its features to\nwhat previous phases already built.\n\nRULES:\n1. Every feature must be assigned to EXACTLY ONE phase (no feature reused, none skipped).\n2. Phases are ordered; later phases depend on earlier ones and yield a more complete product.\n3. product_completion describes concretely what the product can DO once the phase is done.\n4. introduces lists which concepts the phase must teach BEFORE its feature work starts:\n   - aspect new: first time the concept appears in the course\n   - aspect advanced: a concept introduced in an EARLIER phase, revisited here at a\n     higher depth (an advanced aspect of the same concept, e.g. validation rules on top\n     of basic data modeling). Use the note field to say which aspect.\n5. A concept MUST be introduced (new) no later than the first phase that consumes it.\n6. A concept must not be introduced before its own prerequisites are introduced.\n7. Typically 3-6 phases for a small project; keep phases balanced.\n8. Phase 1 usually covers project setup/foundation features plus the first minimal slice.\n9. Return JSON only.";
+  const baseUserPrompt = "FEATURES:\n" + featureList + "\n\nCONCEPTS:\n" + conceptList + "\n\nFEATURE-CONCEPT LINKS:\n" + linkList + "\n\nReturn JSON with a phases array. Each phase: { id: PH1, name, product_completion, feature_ids: [F0, F1], introduces: [{ concept_id: C1, aspect: new or advanced, note }] }.\n";
+  const MAX_DECOMPOSE_ATTEMPTS = 3;
+  let auditErrors = [];
+  let phases = [];
+  let rawPhases = [];
+  for (let attempt = 1; attempt <= MAX_DECOMPOSE_ATTEMPTS; attempt++) {
+    const userPrompt = attempt === 1 ? baseUserPrompt : baseUserPrompt + "\nYOUR PREVIOUS PLAN VIOLATED THESE CONTRACT RULES (fix ALL of them):\n" + auditErrors.map((e) => "- " + e).join("\n") + "\nReturn a corrected full phases array.\n";
+    const result = await llmChatJson(client, systemPrompt, userPrompt, {
+      temperature: 0.1,
+      maxTokens: 16384
+    });
+    rawPhases = result.phases || [];
+    if (rawPhases.length === 0) {
+      if (attempt === MAX_DECOMPOSE_ATTEMPTS) {
+        throw new Error("Phase decomposition returned zero phases - fail-closed abort");
+      }
+      auditErrors = ["Returned zero phases"];
+      continue;
+    }
+    ({ phases, errors: auditErrors } = auditPhasePlan(rawPhases, features, concepts, links));
+    if (auditErrors.length === 0) break;
+    if (attempt < MAX_DECOMPOSE_ATTEMPTS) {
+      log("STEP_2", "Contract violations (" + auditErrors.length + ") - repairing (attempt " + (attempt + 1) + "/" + MAX_DECOMPOSE_ATTEMPTS + ")");
+    }
+  }
+  if (auditErrors.length > 0) {
+    throw new Error(
+      "Phase decomposition violated the progressive-completion contract (" + auditErrors.length + " issue(s)):\n" + auditErrors.map((e) => "  - " + e).join("\n") + "\nRe-run the pipeline - a phase model that cannot be trusted is worse than no output."
+    );
+  }
+  if (phases.length === 1 && features.length > 2) {
+    warnings.push("Only one phase for " + features.length + " features - progressive decomposition likely too coarse");
+  }
+  log("STEP_2", "Decomposed into " + phases.length + " phases: " + phases.map((p) => p.id + "(" + p.feature_ids.length + "F/" + p.introduces.length + "K)").join(", "));
+  return phases;
+}
+
+// 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/detector/inputTypeDetector.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".swift",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".ino",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".kt",
+  ".kts",
+  ".java",
+  ".cs",
+  ".rb",
+  ".go",
+  ".rs",
+  ".php",
+  ".lua",
+  ".r",
+  ".m"
+]);
+var NON_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".stl",
+  ".obj",
+  ".step",
+  ".stp",
+  ".iges",
+  ".igs",
+  // 3D models
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".bmp",
+  // Images
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".pptx",
+  ".xlsx",
+  // Documents
+  ".tc3",
+  ".f3d",
+  // CAD files
+  ".mp3",
+  ".wav",
+  ".midi",
+  // Audio
+  ".mp4",
+  ".avi",
+  ".mov"
+  // Video
+]);
+function detectInputType(options) {
+  const evidence = [];
+  let repoScore = 0;
+  let syllabusScore = 0;
+  let filesScore = 0;
+  let descriptionScore = 0;
+  if (options.repoUrl) {
+    repoScore += 0.5;
+    evidence.push(`repoUrl provided: ${options.repoUrl}`);
+  }
+  if (options.repoDir) {
+    repoScore += 0.5;
+    evidence.push(`repoDir provided: ${options.repoDir}`);
+  }
+  if (options.syllabusText && options.syllabusText.length > 50) {
+    syllabusScore += 0.6;
+    evidence.push(`syllabusText provided (${options.syllabusText.length} chars)`);
+  }
+  if (options.chapters && options.chapters.length > 0) {
+    syllabusScore += 0.4;
+    evidence.push(`${options.chapters.length} chapters provided`);
+  }
+  if (options.fileExtensions && options.fileExtensions.length > 0) {
+    const codeCount = options.fileExtensions.filter((ext) => CODE_EXTENSIONS.has(ext)).length;
+    const nonCodeCount = options.fileExtensions.filter((ext) => NON_CODE_EXTENSIONS.has(ext)).length;
+    if (nonCodeCount > 0) {
+      filesScore += 0.7;
+      evidence.push(`${nonCodeCount} non-code files detected: ${options.fileExtensions.filter((ext) => NON_CODE_EXTENSIONS.has(ext)).join(", ")}`);
+    }
+    if (codeCount > 0 && repoScore === 0) {
+      repoScore += 0.3;
+      evidence.push(`${codeCount} source code files detected`);
+    }
+  }
+  if (options.description && options.description.length > 100) {
+    descriptionScore += 0.5;
+    evidence.push(`description provided (${options.description.length} chars)`);
+  }
+  if (options.goal && options.goal.length > 20) {
+    descriptionScore += 0.3;
+    evidence.push(`goal provided (${options.goal.length} chars)`);
+  }
+  const scores = [
+    { type: "repository", score: repoScore },
+    { type: "syllabus", score: syllabusScore },
+    { type: "files", score: filesScore },
+    { type: "description", score: descriptionScore }
+  ];
+  scores.sort((a, b) => b.score - a.score);
+  const winner = scores[0];
+  const activeTypes = scores.filter((s) => s.score >= 0.3);
+  if (activeTypes.length >= 2) {
+    return {
+      inputType: "mixed",
+      confidence: 0.7,
+      evidence: [...evidence, `Mixed input detected: ${activeTypes.map((t) => t.type).join(" + ")}`]
+    };
+  }
+  if (winner.score === 0) {
+    return {
+      inputType: "description",
+      confidence: 0.3,
+      evidence: [...evidence, "No strong signals \u2014 defaulting to description"]
+    };
+  }
+  return {
+    inputType: winner.type,
+    confidence: Math.min(winner.score, 1),
+    evidence
+  };
+}
+
+// src/detector/domainDetector.ts
+var DOMAIN_KEYWORDS = {
+  software: [
+    "app",
+    "web",
+    "api",
+    "database",
+    "frontend",
+    "backend",
+    "mobile",
+    "swift",
+    "react",
+    "vue",
+    "angular",
+    "node",
+    "python",
+    "java",
+    "typescript",
+    "javascript",
+    "html",
+    "css",
+    "sql",
+    "rest",
+    "graphql",
+    "git",
+    "docker",
+    "kubernetes",
+    "ci/cd",
+    "deploy",
+    "swiftui",
+    "uikit",
+    "flutter",
+    "kotlin",
+    "android",
+    "ios",
+    "nextjs",
+    "nuxt",
+    "svelte",
+    "django",
+    "flask",
+    "express"
+  ],
+  hardware_iot: [
+    "arduino",
+    "robot",
+    "sensor",
+    "motor",
+    "esp32",
+    "gpio",
+    "raspberry pi",
+    "iot",
+    "firmware",
+    "embedded",
+    "microcontroller",
+    "led",
+    "servo",
+    "potentiometer",
+    "breadboard",
+    "soldering",
+    "i2c",
+    "spi",
+    "pwm",
+    "uart",
+    "analog",
+    "digital",
+    "ultrasonic",
+    "infrared",
+    "bluetooth",
+    "wifi module",
+    "pin",
+    "voltage",
+    "resistor",
+    "capacitor",
+    "circuit"
+  ],
+  "3d_design": [
+    "tinkercad",
+    "3d model",
+    "cad",
+    "parametric",
+    "stl",
+    "obj",
+    "fusion360",
+    "blender",
+    "solidworks",
+    "autocad",
+    "freecad",
+    "shape",
+    "dimension",
+    "extrude",
+    "revolve",
+    "fillet",
+    "chamfer",
+    "assembly",
+    "constraint",
+    "sketch",
+    "plane",
+    "axis",
+    "render",
+    "mesh",
+    "nurbs",
+    "surface",
+    "volume"
+  ],
+  math: [
+    // Vietnamese
+    "h\xECnh h\u1ECDc",
+    "\u0111\u1EA1i s\u1ED1",
+    "gi\u1EA3i t\xEDch",
+    "x\xE1c su\u1EA5t",
+    "th\u1ED1ng k\xEA",
+    "tam gi\xE1c",
+    "\u0111\u01B0\u1EDDng tr\xF2n",
+    "ph\u01B0\u01A1ng tr\xECnh",
+    "b\u1EA5t ph\u01B0\u01A1ng tr\xECnh",
+    "s\u1ED1 h\u1ECDc",
+    "t\u1ED5 h\u1EE3p",
+    "ho\xE1n v\u1ECB",
+    "\u0111\u1ED9 \u0111o",
+    "g\xF3c",
+    "c\u1EA1nh",
+    "di\u1EC7n t\xEDch",
+    "th\u1EC3 t\xEDch",
+    "chu vi",
+    "\u0111\u01B0\u1EDDng cao",
+    "trung tuy\u1EBFn",
+    // English
+    "geometry",
+    "algebra",
+    "calculus",
+    "trigonometry",
+    "logarithm",
+    "probability",
+    "statistics",
+    "derivative",
+    "integral",
+    "matrix",
+    "vector",
+    "theorem",
+    "proof",
+    "angle",
+    "perimeter",
+    "area",
+    // Chinese
+    "\u51E0\u4F55",
+    "\u4EE3\u6570",
+    "\u5FAE\u79EF\u5206",
+    "\u6982\u7387",
+    "\u7EDF\u8BA1",
+    "\u4E09\u89D2\u5F62",
+    "\u5706",
+    "\u65B9\u7A0B",
+    // Japanese
+    "\u5E7E\u4F55",
+    "\u4EE3\u6570",
+    "\u5FAE\u5206",
+    "\u7A4D\u5206",
+    "\u78BA\u7387",
+    "\u7D71\u8A08",
+    // French
+    "g\xE9om\xE9trie",
+    "alg\xE8bre",
+    "calcul",
+    "trigonom\xE9trie",
+    "probabilit\xE9"
+  ],
+  science: [
+    // Vietnamese
+    "l\xFD thuy\u1EBFt",
+    "nguy\xEAn l\xFD",
+    "th\xED nghi\u1EC7m",
+    "\u0111i\u1EC7n",
+    "l\u1EF1c",
+    "h\xF3a h\u1ECDc",
+    "sinh h\u1ECDc",
+    "v\u1EADt l\xFD",
+    "\u0111\u1ECBa l\xFD",
+    "ph\u1EA3n \u1EE9ng",
+    "nguy\xEAn t\u1ED1",
+    "ph\xE2n t\u1EED",
+    "n\u0103ng l\u01B0\u1EE3ng",
+    "c\u1EA3m \u1EE9ng",
+    "t\u1EEB tr\u01B0\u1EDDng",
+    "quang h\u1ECDc",
+    "m\xF4i tr\u01B0\u1EDDng",
+    "sinh th\xE1i",
+    // English
+    "physics",
+    "chemistry",
+    "biology",
+    "earth science",
+    "cell",
+    "gene",
+    "evolution",
+    "ecosystem",
+    "molecule",
+    "atom",
+    // Chinese
+    "\u7269\u7406",
+    "\u5316\u5B66",
+    "\u751F\u7269",
+    "\u5730\u7406",
+    // Japanese
+    "\u7269\u7406",
+    "\u5316\u5B66",
+    "\u751F\u7269",
+    // French
+    "physique",
+    "chimie",
+    "biologie"
+  ],
+  language: [
+    // Vietnamese
+    "ti\u1EBFng anh",
+    "ti\u1EBFng vi\u1EC7t",
+    "ng\u1EEF ph\xE1p",
+    "t\u1EEB v\u1EF1ng",
+    "\u0111\u1ECDc",
+    "vi\u1EBFt",
+    "n\xF3i",
+    "nghe",
+    // English
+    "grammar",
+    "vocabulary",
+    "writing",
+    "reading",
+    "speaking",
+    "listening",
+    "pronunciation",
+    "essay",
+    "paragraph",
+    "sentence",
+    "verb",
+    "noun",
+    "adjective",
+    "ielts",
+    "toeic",
+    "toefl",
+    // Chinese
+    "\u82F1\u8BED",
+    "\u8BED\u6CD5",
+    "\u8BCD\u6C47",
+    "\u9605\u8BFB",
+    "\u5199\u4F5C",
+    // Japanese
+    "\u82F1\u8A9E",
+    "\u6587\u6CD5",
+    "\u8A9E\u5F59",
+    "\u8AAD\u89E3",
+    "\u4F5C\u6587",
+    // French
+    "anglais",
+    "grammaire",
+    "vocabulaire",
+    "lecture",
+    "\xE9criture"
+  ],
+  arts: [
+    // Vietnamese
+    "\xE2m nh\u1EA1c",
+    "nh\u1EA1c l\xFD",
+    "solf\xE8ge",
+    "\u0111\xE0n",
+    "piano",
+    "guitar",
+    "h\u1ED9i h\u1ECDa",
+    "thi\u1EBFt k\u1EBF",
+    "nhi\u1EBFp \u1EA3nh",
+    "tranh",
+    "m\xE0u",
+    "s\xE1ng t\xE1c",
+    "bi\xEAn kh\xFAc",
+    // English
+    "music",
+    "art",
+    "painting",
+    "drawing",
+    "sketch",
+    "photography",
+    "color theory",
+    "composition",
+    "typography",
+    "layout",
+    "digital art",
+    "illustration",
+    "figma",
+    // Chinese
+    "\u97F3\u4E50",
+    "\u7F8E\u672F",
+    "\u7ED8\u753B",
+    "\u6444\u5F71",
+    "\u8BBE\u8BA1",
+    // Japanese
+    "\u97F3\u697D",
+    "\u7F8E\u8853",
+    "\u7D75\u753B",
+    "\u5199\u771F",
+    "\u30C7\u30B6\u30A4\u30F3",
+    // French
+    "musique",
+    "art",
+    "peinture",
+    "dessin",
+    "photographie"
+  ],
+  research: [
+    // Vietnamese
+    "nghi\xEAn c\u1EE9u",
+    "th\u1ED1ng k\xEA",
+    "ph\u01B0\u01A1ng ph\xE1p lu\u1EADn",
+    "ph\xE2n t\xEDch d\u1EEF li\u1EC7u",
+    "\u0111\u1ECBnh t\xEDnh",
+    "\u0111\u1ECBnh l\u01B0\u1EE3ng",
+    "gi\u1EA3 thuy\u1EBFt",
+    "m\u1EABu",
+    "t\u1ED5ng th\u1EC3",
+    "t\u01B0\u01A1ng quan",
+    "h\u1ED3i quy",
+    "t\xE0i li\u1EC7u tham kh\u1EA3o",
+    "tr\xEDch d\u1EABn",
+    "t\xF3m t\u1EAFt",
+    // English
+    "research",
+    "survey",
+    "methodology",
+    "data analysis",
+    "qualitative",
+    "quantitative",
+    "hypothesis",
+    "experiment",
+    "sample",
+    "population",
+    "correlation",
+    "regression",
+    "literature review",
+    "citation",
+    "abstract",
+    // Chinese
+    "\u7814\u7A76",
+    "\u8C03\u67E5",
+    "\u65B9\u6CD5\u8BBA",
+    "\u6570\u636E\u5206\u6790",
+    // Japanese
+    "\u7814\u7A76",
+    "\u8ABF\u67FB",
+    "\u65B9\u6CD5\u8AD6",
+    "\u30C7\u30FC\u30BF\u5206\u6790",
+    // French
+    "recherche",
+    "enqu\xEAte",
+    "m\xE9thodologie",
+    "analyse de donn\xE9es"
+  ],
+  business: [
+    // Vietnamese
+    "kinh doanh",
+    "t\xE0i ch\xEDnh",
+    "qu\u1EA3n l\xFD",
+    "marketing",
+    "b\xE1n h\xE0ng",
+    "kh\u1EDFi nghi\u1EC7p",
+    "k\u1EBF ho\u1EA1ch kinh doanh",
+    "doanh thu",
+    "l\u1EE3i nhu\u1EADn",
+    "qu\u1EA3n tr\u1ECB",
+    "t\xE0i kho\u1EA3n",
+    "\u0111\u1EA7u t\u01B0",
+    "ng\xE2n s\xE1ch",
+    // English
+    "business",
+    "finance",
+    "accounting",
+    "investment",
+    "budget",
+    "startup",
+    "revenue",
+    "profit",
+    "roi",
+    "sales",
+    "product management",
+    "agile",
+    "scrum",
+    "kanban",
+    // Chinese
+    "\u5546\u4E1A",
+    "\u91D1\u878D",
+    "\u4F1A\u8BA1",
+    "\u6295\u8D44",
+    "\u8425\u9500",
+    // Japanese
+    "\u30D3\u30B8\u30CD\u30B9",
+    "\u91D1\u878D",
+    "\u4F1A\u8A08",
+    "\u6295\u8CC7",
+    "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0",
+    // French
+    "affaires",
+    "finance",
+    "comptabilit\xE9",
+    "investissement"
+  ],
+  other: []
+};
+var EXTENSION_DOMAIN = {
+  ".swift": "software",
+  ".ts": "software",
+  ".tsx": "software",
+  ".js": "software",
+  ".jsx": "software",
+  ".py": "software",
+  ".kt": "software",
+  ".kts": "software",
+  ".java": "software",
+  ".cs": "software",
+  ".go": "software",
+  ".rs": "software",
+  ".rb": "software",
+  ".php": "software",
+  ".lua": "software",
+  ".r": "software",
+  // .ino is ALWAYS hardware
+  ".ino": "hardware_iot",
+  // .cpp/.c/.h are CONTEXT-DEPENDENT → resolve in detection logic
+  ".stl": "3d_design",
+  ".obj": "3d_design",
+  ".step": "3d_design",
+  ".stp": "3d_design",
+  ".tc3": "3d_design",
+  ".f3d": "3d_design"
+};
+var AMBIGUOUS_EXTENSIONS = /* @__PURE__ */ new Set([".cpp", ".c", ".h", ".hpp"]);
+var LANG_PATTERNS = [
+  { lang: "vi", patterns: [/[ạảãàáạảãạ]/i, /\bgiải\b/, /\btính\b/] },
+  { lang: "zh", patterns: [/[\u4e00-\u9fff]{2,}/] },
+  { lang: "ja", patterns: [/[\u3040-\u309f\u30a0-\u30ff]{2,}/] },
+  { lang: "ko", patterns: [/[\uac00-\ud7af]{2,}/] },
+  { lang: "fr", patterns: [/\b(la|le|les|des|une|est|sont|avec|pour|dans)\b/i] }
+];
+function detectSyllabusLanguage(text) {
+  for (const { lang, patterns } of LANG_PATTERNS) {
+    if (patterns.some((p) => p.test(text))) return lang;
+  }
+  return "en";
+}
+function detectDomain(options) {
+  const evidence = [];
+  const detectedTechStack = [];
+  let detectedSubject = "";
+  let ambiguous;
+  const scores = {
+    software: 0,
+    hardware_iot: 0,
+    "3d_design": 0,
+    math: 0,
+    science: 0,
+    language: 0,
+    arts: 0,
+    research: 0,
+    business: 0,
+    other: 0
+  };
+  const hasHardwareContext = !!(options.techStack?.toLowerCase().match(/arduino|esp32|raspberry|embedded|iot/) || options.description?.toLowerCase().match(/arduino|robot|sensor|motor|circuit/) || options.goal?.toLowerCase().match(/arduino|robot|sensor|motor|circuit/));
+  const hasSoftwareContext = !!(options.techStack?.toLowerCase().match(/swift|react|vue|angular|python|java|typescript|javascript/) || options.description?.toLowerCase().match(/app|web|api|frontend|backend|mobile/) || options.goal?.toLowerCase().match(/app|web|api|frontend|backend|mobile/));
+  if (options.fileExtensions) {
+    for (const ext of options.fileExtensions) {
+      const extLower = ext.toLowerCase();
+      if (extLower === ".ino") {
+        scores.hardware_iot += 0.5;
+        evidence.push(`File extension ${ext} \u2192 hardware_iot (always)`);
+        continue;
+      }
+      if (AMBIGUOUS_EXTENSIONS.has(extLower)) {
+        if (hasHardwareContext && !hasSoftwareContext) {
+          scores.hardware_iot += 0.3;
+          evidence.push(`File extension ${ext} \u2192 hardware_iot (hardware context)`);
+        } else if (hasSoftwareContext && !hasHardwareContext) {
+          scores.software += 0.3;
+          evidence.push(`File extension ${ext} \u2192 software (software context)`);
+        } else if (hasHardwareContext && hasSoftwareContext) {
+          scores.software += 0.15;
+          scores.hardware_iot += 0.15;
+          evidence.push(`File extension ${ext} \u2192 ambiguous (both software and hardware context)`);
+          ambiguous = {
+            domain1: "software",
+            domain2: "hardware_iot",
+            reason: `.cpp/.c/.h files present with both software and hardware context keywords`
+          };
+        } else {
+          scores.software += 0.2;
+          evidence.push(`File extension ${ext} \u2192 software (default, no context)`);
+        }
+        continue;
+      }
+      const domain = EXTENSION_DOMAIN[extLower];
+      if (domain) {
+        scores[domain] += 0.3;
+        evidence.push(`File extension ${ext} \u2192 ${domain}`);
+      }
+    }
+  }
+  const textContent = [
+    options.description || "",
+    options.goal || "",
+    options.syllabusText || ""
+  ].join(" ").toLowerCase();
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+    const cat = domain;
+    for (const kw of keywords) {
+      if (textContent.includes(kw.toLowerCase())) {
+        scores[cat] += 0.1;
+        if (!evidence.some((e) => e.includes(`"${kw}"`))) {
+          evidence.push(`Keyword "${kw}" \u2192 ${cat}`);
+        }
+      }
+    }
+  }
+  if (options.techStack) {
+    const techItems = options.techStack.split(",").map((t) => t.trim());
+    for (const tech of techItems) {
+      const techL = tech.toLowerCase();
+      if (["swift", "swiftui", "uikit", "ios"].some((k) => techL.includes(k))) {
+        scores.software += 0.4;
+        detectedTechStack.push(tech);
+      } else if (["react", "vue", "angular", "next", "nuxt", "typescript", "javascript"].some((k) => techL.includes(k))) {
+        scores.software += 0.4;
+        detectedTechStack.push(tech);
+      } else if (["python", "django", "flask"].some((k) => techL.includes(k))) {
+        scores.software += 0.3;
+        detectedTechStack.push(tech);
+      } else if (["arduino", "esp32", "raspberry"].some((k) => techL.includes(k))) {
+        scores.hardware_iot += 0.5;
+        detectedTechStack.push(tech);
+      } else if (["tinkercad", "fusion360", "blender"].some((k) => techL.includes(k))) {
+        scores["3d_design"] += 0.5;
+        detectedTechStack.push(tech);
+      } else if (["c++", "c", "cpp"].some((k) => techL === k || techL.endsWith(k))) {
+        if (hasHardwareContext) {
+          scores.hardware_iot += 0.3;
+        } else {
+          scores.software += 0.3;
+        }
+        detectedTechStack.push(tech);
+      }
+    }
+  }
+  if (options.syllabusText) {
+    const syllabusLang = detectSyllabusLanguage(options.syllabusText);
+    const syllabusLower = options.syllabusText.toLowerCase();
+    if (syllabusLower.includes("h\xECnh h\u1ECDc") || syllabusLower.includes("\u0111\u1EA1i s\u1ED1") || syllabusLower.includes("geometry") || syllabusLower.includes("algebra") || syllabusLower.includes("\u51E0\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("\u5E7E\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("g\xE9om\xE9trie") || syllabusLower.includes("alg\xE8bre")) {
+      scores.math += 0.5;
+      detectedSubject = "Mathematics";
+    } else if (syllabusLower.includes("v\u1EADt l\xFD") || syllabusLower.includes("h\xF3a") || syllabusLower.includes("sinh") || syllabusLower.includes("physics") || syllabusLower.includes("chemistry") || syllabusLower.includes("biology") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("physique") || syllabusLower.includes("chimie")) {
+      scores.science += 0.5;
+      detectedSubject = "Natural Science";
+    } else if (syllabusLower.includes("ti\u1EBFng anh") || syllabusLower.includes("english") || syllabusLower.includes("grammar") || syllabusLower.includes("\u82F1\u8BED") || syllabusLower.includes("\u82F1\u8A9E") || syllabusLower.includes("anglais")) {
+      scores.language += 0.5;
+      detectedSubject = "English Language";
+    }
+    evidence.push(`Syllabus language detected: ${syllabusLang}`);
+  }
+  const entries = Object.entries(scores).filter(([k]) => k !== "other");
+  entries.sort((a, b) => b[1] - a[1]);
+  const [winner, winnerScore] = entries[0];
+  if (winnerScore === 0) {
+    return {
+      domainCategory: "other",
+      confidence: 0.2,
+      evidence: [...evidence, "No domain signals detected"],
+      detectedTechStack,
+      detectedSubject
+    };
+  }
+  const second = entries[1];
+  if (second && winnerScore - second[1] < 0.15 && winnerScore > 0) {
+    ambiguous = {
+      domain1: winner,
+      domain2: second[0],
+      reason: `Scores very close: ${winner}=${winnerScore.toFixed(2)}, ${second[0]}=${second[1].toFixed(2)}`
+    };
+  }
+  const totalScore = entries.reduce((sum, [, s]) => sum + s, 0);
+  const confidence = totalScore > 0 ? Math.min(winnerScore / totalScore + 0.3, 1) : 0.3;
+  return {
+    domainCategory: winner,
+    confidence,
+    evidence: evidence.slice(0, 20),
+    detectedTechStack,
+    detectedSubject,
+    ambiguous
+  };
+}
+
+// src/detector/learningModeDetector.ts
+var BUILD_VERBS = [
+  "build",
+  "create",
+  "develop",
+  "implement",
+  "construct",
+  "make",
+  "x\xE2y d\u1EF1ng",
+  "t\u1EA1o",
+  "ph\xE1t tri\u1EC3n",
+  "tri\u1EC3n khai",
+  "l\u1EAFp r\xE1p",
+  "code",
+  "program",
+  "design a",
+  "set up",
+  "deploy"
+];
+var UNDERSTAND_VERBS = [
+  "understand",
+  "learn",
+  "grasp",
+  "comprehend",
+  "master",
+  "hi\u1EC3u",
+  "n\u1EAFm v\u1EEFng",
+  "h\u1ECDc",
+  "ti\u1EBFp thu",
+  "am hi\u1EC3u",
+  "v\u1EADn d\u1EE5ng",
+  "ph\xE2n t\xEDch",
+  "\u0111\xE1nh gi\xE1",
+  "so s\xE1nh",
+  "explain",
+  "describe",
+  "analyze",
+  "evaluate",
+  "compare"
+];
+var CONCEPT_DOMAINS = ["math", "science", "language", "arts", "research", "business"];
+var PRODUCT_DOMAINS = ["software", "hardware_iot", "3d_design"];
+function detectLearningMode(options) {
+  const evidence = [];
+  const text = [options.goal || "", options.description || ""].join(" ").toLowerCase();
+  let productScore = 0;
+  let conceptScore = 0;
+  if (options.hasRepo) {
+    productScore += 0.3;
+    evidence.push("Repository present \u2192 product signal");
+  }
+  if (options.hasSyllabus) {
+    conceptScore += 0.3;
+    evidence.push("Syllabus present \u2192 concept signal");
+  }
+  if (PRODUCT_DOMAINS.includes(options.domainCategory)) {
+    productScore += 0.2;
+    evidence.push(`Domain ${options.domainCategory} \u2192 product\u503E\u5411`);
+  }
+  if (CONCEPT_DOMAINS.includes(options.domainCategory)) {
+    conceptScore += 0.2;
+    evidence.push(`Domain ${options.domainCategory} \u2192 concept\u503E\u5411`);
+  }
+  const hasBuildVerbs = BUILD_VERBS.some((v) => text.includes(v));
+  const hasUnderstandVerbs = UNDERSTAND_VERBS.some((v) => text.includes(v));
+  if (hasBuildVerbs) {
+    productScore += 0.3;
+    evidence.push("Build verbs detected in goal/description");
+  }
+  if (hasUnderstandVerbs) {
+    conceptScore += 0.3;
+    evidence.push("Understand verbs detected in goal/description");
+  }
+  const total = productScore + conceptScore;
+  if (total === 0) {
+    return {
+      learningMode: "product",
+      confidence: 0.3,
+      evidence: [...evidence, "No signals \u2014 defaulting to product"]
+    };
+  }
+  if (productScore >= 0.3 && conceptScore >= 0.3) {
+    const hybridConf = Math.min((productScore + conceptScore) / 2, 1);
+    return {
+      learningMode: "hybrid",
+      confidence: hybridConf,
+      evidence: [...evidence, `Mixed signals: product=${productScore.toFixed(2)}, concept=${conceptScore.toFixed(2)} \u2192 hybrid`]
+    };
+  }
+  if (productScore > conceptScore) {
+    const raw2 = total > 0 ? productScore / total : 0.5;
+    return {
+      learningMode: "product",
+      confidence: Math.min(Math.max(raw2, 0) + 0.2, 1),
+      evidence
+    };
+  }
+  const raw = total > 0 ? conceptScore / total : 0.5;
+  return {
+    learningMode: "concept",
+    confidence: Math.min(Math.max(raw, 0) + 0.2, 1),
+    evidence
+  };
+}
+
+// src/detector/domainProfileDetector.ts
+function detectDomainProfile(options) {
+  const effectiveSyllabus = options.syllabusText || options.parsedSyllabus?.rawText || "";
+  const inputResult = detectInputType({
+    ...options,
+    syllabusText: effectiveSyllabus
+  });
+  const domainResult = detectDomain({
+    description: options.description,
+    goal: options.goal,
+    syllabusText: effectiveSyllabus,
+    techStack: options.techStack,
+    fileExtensions: options.fileExtensions,
+    repoUrl: options.repoUrl
+  });
+  const modeResult = detectLearningMode({
+    inputType: inputResult.inputType,
+    domainCategory: domainResult.domainCategory,
+    goal: options.goal,
+    description: options.description,
+    hasRepo: !!(options.repoUrl || options.repoDir),
+    hasSyllabus: !!(effectiveSyllabus || options.chapters && options.chapters.length > 0 || options.parsedSyllabus)
+  });
+  const graphType = determineGraphType(modeResult.learningMode);
+  return {
+    inputType: inputResult.inputType,
+    domainCategory: domainResult.domainCategory === "other" && options.parsedSyllabus?.subject.domain ? options.parsedSyllabus.subject.domain : domainResult.domainCategory,
+    learningMode: modeResult.learningMode,
+    graphType,
+    confidence: {
+      inputType: inputResult.confidence,
+      domainCategory: domainResult.confidence,
+      learningMode: modeResult.confidence
+    },
+    evidence: [...inputResult.evidence, ...domainResult.evidence, ...modeResult.evidence],
+    detectedTechStack: domainResult.detectedTechStack,
+    detectedSubject: options.parsedSyllabus?.subject.title || domainResult.detectedSubject,
+    detectedDomain: domainResult.domainCategory,
+    goal: options.goal || "",
+    description: options.description || "",
+    repoUrl: options.repoUrl || "",
+    repoDir: options.repoDir || "",
+    syllabusText: effectiveSyllabus
+  };
+}
+function determineGraphType(learningMode) {
+  switch (learningMode) {
+    case "product":
+      return "project_graph";
+    case "concept":
+      return "knowledge_graph";
+    case "hybrid":
+      return "hybrid_graph";
+    default:
+      return "project_graph";
+  }
+}
+
+// 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.runDomainPipeline = runDomainPipeline;
+exports.runHybridGraphPipeline = runHybridGraphPipeline;
+exports.runKnowledgeGraphPipeline = runKnowledgeGraphPipeline;
 exports.runProjectGraphPipeline = runProjectGraphPipeline;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map